随笔- 20 文章- 337 评论- 8 阅读- 32万

Java多线程的一些面试心得

最近面试一直被多线程所折磨。因为之前的公司一直没有太多高并发的处理，所以对JAVA的多线程并没有太多实战经验。今天面试的时候再多线程上被虐的很惨。晚上回来赶紧写一下demo去理解一下。

事例1：

 1 public class A
 2 {
 3     public synchronized static void m1()
 4     {
 5         System.out.println("m1");
 6         try
 7         {
 8             Thread.sleep(3000);
 9         } catch (InterruptedException e)
10         {
11             // TODO Auto-generated catch block
12             e.printStackTrace();
13         }
14     }
15     public synchronized static void m2()
16     {
17         System.out.println("m2");
18         try
19         {
20             Thread.sleep(3000);
21         } catch (InterruptedException e)
22         {
23             // TODO Auto-generated catch block
24             e.printStackTrace();
25         }
26     }
27     public synchronized void m3()
28     {
29         System.out.println("m3");
30         try
31         {
32             Thread.sleep(3000);
33         } 
34         catch (InterruptedException e)
35         {
36             // TODO Auto-generated catch block
37             e.printStackTrace();
38         }
39     }
40     public synchronized void m4()
41     {
42         System.out.println("m4");
43         try
44         {
45             Thread.sleep(3000);
46         } catch (InterruptedException e)
47         {
48             // TODO Auto-generated catch block
49             e.printStackTrace();
50         }
51     }
52     public void m5()
53     {
54         System.out.println("m5");
55         try
56         {
57             Thread.sleep(3000);
58         } catch (InterruptedException e)
59         {
60             // TODO Auto-generated catch block
61             e.printStackTrace();
62         }
63     }
64     public static void main(String[] args)
65     {
66         final A a1 = new A();
67         final A a2 = new A();
68         new Thread(new Runnable()
69         {
70             
71             @Override
72             public void run()
73             {
74                 A.m1();
75                 A.m2();
76                 a1.m3();
77                 a1.m4();
78             }
79         },"T1").start();
80         
81         new Thread(new Runnable()
82         {
83             
84             @Override
85             public void run()
86             {
87                 A.m1();
88                 A.m2();
89                 a1.m3();
90                 a1.m4();
91             }
92         },"T2").start();
93     }
94 }

对于静态方法来说，他们的同步，实际上锁的是这个.class，这个类。

所以对于多个线程是无法并发访问 A.m1()和A.m1()的，也无法同时访问A.m1()和A.m2();

对于非静态方法，他们的同步，实际上锁的是这个对象的this实例。所以同时只能有一个线程去调用这个对象里面的同步方法。

由此可见：

T1访问A.m1() T2访问a1.m3()，可以并发访问

T1访问A.m2() T2访问a1.m4()，可以并发访问

但

T1访问a1.m3() T2访问a1.m3()，不可以并发访问，他们公用同一个this

T1访问a1.m3() T2访问a1.m4()，也不可以并发访问，他们公用同一个this

T1访问a1.m3() T2访问a2.m3()，可以并发访问，他们锁定的是两个this

T1访问a1.m3() T2访问a1.m5()，可以并发访问，m5没有被synchronized修饰

事例2：

现在我们需要编写这样一个代码：有五个txt文件，我们需要用五个线程对这5个文件进行字符统计，最后在汇总这5个文件的字符出现的次数。

  1 import java.io.FileNotFoundException;
  2 import java.io.FileReader;
  3 import java.io.IOException;
  4 import java.util.ArrayList;
  5 import java.util.HashMap;
  6 import java.util.List;
  7 import java.util.Map;
  8 import java.util.Set;
  9 import java.util.concurrent.CountDownLatch;
 10 
 11 
 12 class ThreadTest implements Runnable{
 13     private int num;
 14     public Map<Character, Integer> map = new HashMap<Character, Integer>(){};
 15     private CountDownLatch latch = null;
 16     public ThreadTest(int i, CountDownLatch latch)
 17     {
 18         this.num = i;
 19         this.latch = latch;
 20     }
 21     
 22     @Override
 23     public void run()
 24     {
 25         FileReader fr;
 26         try
 27         {
 28             fr = new FileReader(num + ".txt");
 29         } 
 30         catch (FileNotFoundException e)
 31         {
 32             System.out.println("File " + num + ".txt not find");
 33             return ;
 34         }  
 35         int ch = 0;  
 36         try
 37         {
 38             while((ch = fr.read())!=-1 )  
 39             {  
 40                 char c = (char) ch;
 41                 if ( map.containsKey(c) )
 42                 {
 43                     int count = map.get(c);
 44                     count ++;
 45                     map.put(c, count);
 46                 } else{
 47                     map.put(c, 1);
 48                 }
 49             }
 50             latch.countDown();
 51         } 
 52         catch (IOException e)
 53         {
 54             
 55         }  
 56     }        
 57 }
 58 
 59 public class B
 60 {
 61     public static final int N = 5;
 62     public static void main(String[] args) throws InterruptedException
 63     {
 64         List<ThreadTest> threadTestList = new ArrayList<ThreadTest>(){};
 65         List<Thread> threadList = new ArrayList<Thread>(){};
 66         CountDownLatch latch = new CountDownLatch(N);
 67         for (int i = 0; i < N; i++)
 68         {
 69             ThreadTest threadTest = new ThreadTest(i, latch);
 70             threadTestList.add(threadTest);
 71             Thread thread = new Thread(threadTest);
 72             threadList.add(thread);
 73         }
 74         for (int i = 0; i < N; i++ )
 75         {
 76             threadList.get(i).start();
 77         }
 78         latch.await();
 79         Map<Character, Integer> result = new HashMap<Character, Integer>(){};
 80         for ( ThreadTest threadTest : threadTestList )
 81         {
 82             Set<Character> charList = threadTest.map.keySet();
 83             for (Character ch : charList)
 84             {
 85                 if ( result.containsKey(ch) )
 86                 {
 87                     Integer count = result.get(ch);
 88                     count += threadTest.map.get(ch);
 89                     result.put(ch, count);
 90                 } else
 91                 {
 92                     result.put(ch, threadTest.map.get(ch));
 93                 }
 94             }
 95         }
 96         for (Character ch : result.keySet() )
 97         {
 98             System.out.println(ch + "   " + result.get(ch));
 99         }
100     }
101 
102 }