少年阿宾

那些青春的岁月
  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  500 Posts :: 0 Stories :: 135 Comments :: 0 Trackbacks
面试时的两个技术问题 讨论一下。。
1. 全局变量num=0 
  两个线程同时执行以下代码 
  { 
     for(int i=0;i<50;i++){ 
        num+=1; 
     } 
   } 
    
  最终num值的范围是什么？ 


2. 设计一个并发量100左右的系统 从服务器 应用 手段各个角度考虑  


10

第一题应该是 
50到100 

并发100的话，考虑数据库连接池，缓存，并发安全上 使用锁，队列

4 小时前
kidding87kidding87 
1358 
0 0 8
00

引用
+ 和 =是两个操作吧 ， 不会有这种情况： 线程1的+操作正在进行， 线程2的循环结束， 线程1才开始执行=操作吗。  

还有int变量如果不加volatile关键字， 变量貌似是存放在各自的寄存器缓存里的， 而不一定什么时候才赋值给全局变量。。 有没有可能发生 线程2num赋值为50 而线程1重新把num变为1呢。。 

或者线程2执行到49时， 线程1赋值给全局变量1 ， 此时线程2拿到的num又变为1了？
其实差不多就是这样子的。。。。所以答案应该是50~100 

16 分钟前
asytyasyty 
1434 
0 0 10
00

用scala写的，都是用的java的类库，你改成java代码就可以了，结果50-100. 

Scala代码  收藏代码
  1. object SzStudy extends App {  
  2.   import java.util.LinkedList  
  3.   import java.util.concurrent._  
  4.   var num = 0  
  5.   val pool = Executors.newFixedThreadPool(2)  
  6.   val calls = new LinkedList[Callable[Unit]]();  
  7.   val call = new Callable[Unit] {  
  8.     def call() {  
  9.       for (i <- 0 to 49) {  
  10.         num += 1  
  11.       }  
  12.     }  
  13.   }  
  14.   calls.addLast(call)  
  15.   calls.addLast(call)  
  16.   val fa = pool.invokeAll(calls)  
  17.   val iter=fa.iterator  
  18.   //阻塞主线程，等两个子线程运行完  
  19.   while(iter.hasNext){  
  20.     iter.next.get()  
  21.   }  
  22.   println(num)  
  23. }  

30 分钟前
tlde_titlde_ti 
16 
0 0 1
00

要看主子线程的阻塞程度了。 
如zhangzehao 所写，两个子线处理速度足够快，那结构就是100 
如果子线程阻塞程度高，主线程没有阻塞那 也就是0或是1 
总所有情况取之范围应该会在0-100之间 

3 小时前
zhaoshunxinzhaoshunxin 
202 
0 0 1
00

看了回答，同志们真心不看题啊，第一题问num最后的值是多少，不是让写程序。 
个人感觉是50~100，测实测 
第二题：并发量100该如何控控制，求教高手!这个真心不懂

3 小时前
chairmanMaochairmanMao 
12 
0 0 4
00

public static void main(String[] args){ 

Thread thread1 = new Thread(new Runnable() { 
@Override 
public void run() { 
for(int i=0;i<50;i++){ 
num++; 
System.out.println(num); 
} 
} 
}); 

Thread thread2 = new Thread(new Runnable() { 
@Override 
public void run() { 
for(int i=0;i<50;i++){ 
num++; 
System.out.println(num); 
} 
} 
}); 

thread1.start(); 
thread2.start(); 
}

3 小时前
zhangzehaozhangzehao 
30 
0 0 0
00

上面那个有点问题，保证线程2先拿到； 
这里最后的结果就是1,，但是对于计算机来说 
num+=1; 这里执行的时间是一样多的，所以并不会出现线程1执行完了，线程2才执行了1步这种情况 

Java代码  收藏代码
  1. static  int num =0;  
  2.   
  3. public static void c(){  
  4.     Thread t1 = new Thread(){  
  5.         @Override  
  6.         public void run() {  
  7.             try {  
  8.                 sleep(1000);  
  9.             } catch (InterruptedException e) {  
  10.                 e.printStackTrace();  
  11.             }  
  12.             for(int i=0;i<50;i++)  
  13.             num+=1;  
  14.         }  
  15.     };  
  16.       
  17.    Thread t2=   new Thread(){  
  18.         @Override  
  19.         public void run() {  
  20.             try {  
  21.                                       //线程2先拿到num，然后阻塞住  
  22.                 sleep(999);  
  23.             for(int i=0;i<50;i++){  
  24.                     int temp = num;  
  25.                     if(i==0){  
  26.                         sleep(1000);  
  27.                         temp+=1;  
  28.                         num=temp;  
  29.                     }  
  30.             }  
  31.             } catch (InterruptedException e) {  
  32.                 e.printStackTrace();  
  33.             }  
  34.         }  
  35.     };  
  36.     t1.start();  
  37.     t2.start();  
  38. }  
  39. public static void main(String[] args) {  
  40.     c();  
  41.     try {  
  42.         Thread.sleep(4000);  
  43.     } catch (InterruptedException e) {  
  44.         e.printStackTrace();  
  45.     }  
  46.     System.out.println(num);  
  47. }  

3 小时前
kidding87kidding87 
1358 
0 0 8
00

就算阻塞了它还是要循环的啊 
线程2这个时间很慢，按照你说的模拟了下 

Java代码  收藏代码
  1. static  int num =0;  
  2.   
  3. public static void c(){  
  4.     Thread t1 = new Thread(){  
  5.         @Override  
  6.         public void run() {  
  7.             try {  
  8.                 sleep(1000);  
  9.             } catch (InterruptedException e) {  
  10.                 e.printStackTrace();  
  11.             }  
  12.             for(int i=0;i<50;i++)  
  13.             num+=1;  
  14.         }  
  15.     };  
  16.       
  17.    Thread t2=   new Thread(){  
  18.         @Override  
  19.         public void run() {  
  20.             try {  
  21.                 sleep(1000);  
  22.             for(int i=0;i<50;i++){  
  23.                     int temp = num;  
  24.                     if(i==0){  
  25.                         sleep(1000);  
  26.                         temp+=1;  
  27.                         num=temp;  
  28.                     }  
  29.             }  
  30.             } catch (InterruptedException e) {  
  31.                 e.printStackTrace();  
  32.             }  
  33.         }  
  34.     };  
  35.     t1.start();  
  36.     t2.start();  
  37. }  
  38. public static void main(String[] args) {  
  39.     c();  
  40.     try {  
  41.         Thread.sleep(4000);  
  42.     } catch (InterruptedException e) {  
  43.         e.printStackTrace();  
  44.     }  
  45.     System.out.println(num);  
  46. }  

3 小时前
kidding87kidding87 
1358 
0 0 8
00

tomcat 本身 默认支持的并发为200.配和连接池，完全给解决 第一个 50
























http://www.iteye.com/problems/84994 
























http://www.iteye.com/problems/84994 
posted on 2012-06-21 13:23 abin 阅读(526) 评论(0)  编辑  收藏 所属分类: Java Face

只有注册用户登录后才能发表评论。
网站导航: