黑马程序员—学习笔记—多线程

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

多线程

多线程的运行出现了安全问题的原因：

当多条语句在操作同一个线程共享数据的时候，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据错误。

 

解决的办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可参与执行。

Java对于多线程的安全问题，提供了专业的解决方式。

就是同步代码块。

[java]  view plain copy

1. Synchronized(对象)  
2. {  
3.    //需要被同步的代码。  
4. }  

这里的对象如同一个锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取了cpu的执行权，也进不去，因为没有锁。

 

线程同步的书写前提：（也就是当用了同步之后依然出现线程安全问题）

1.   必须要有两个或者两个以上的线程。

2.   必须是多个线程使用同一个锁。（十分的重要）

 

如何找一个程序中是否会发生多线程安全的问题。

1.   明确哪些代码是多线程运行的代码。（run方法中的都是）

2.   明确哪些数据是共享数据。（公共资源的数据）

3.   明确多线程运行代码中哪些语句是操作共享数据的（是否是多条数据操作）。

同步函数的锁是this。

静态进内存时候，内存中没有本类的对象，但是一定有该类对应的字节码文件对象。

所以静态同步函数的锁是这个函数所对应的类的字节码文件对象（类名.class对象）。该对象的类型是Class。

 

单例模式：使一个类只能有一个实例对象。

有懒汉式和饿汉式两种方式：

懒汉式：实例的延迟加载。

在多线程中有一定的问题，可以加同步来解决，而同步的方式，用同步代码块和同步函数都可以，但是稍微有些低效。使用双重否定的方式可以避免每次得到对象的时候都去验证锁，解决这个效率问题。加同步的时候，使用的锁是该类所属的字节码文件对象

示例如下：

//懒汉式

[java]  view plain copy

1. //懒汉式  
2. class SingleClass  
3. {  
4.     private SingleClass()  
5.     {  
6.     System.out.println("create class");  
7.     }  
8.   
9.     private static SingleClass singleClass;  
10.   
11.     public static SingleClass getSingle()  
12.     {  
13.     if (singleClass == null)  
14.     {  
15.         synchronized (SingleTest.class)  
16.         {  
17.         if (singleClass == null)  
18.         {  
19.             singleClass = new SingleClass();  
20.         }  
21.         }  
22.     }  
23.     return singleClass;  
24.     }  
25. }  
26. //饿汉式  
27.  class SingleClass  
28.  {  
29.  private SingleClass()  
30.  {  
31.       
32.  }  
33.  private static final SingleClass singleClass = new SingleClass();  
34.       
35.       
36.  public static SingleClass getSingle()  
37.  {  
38.  return singleClass;  
39.  }  
40.       
41.  }  

线程中通信的等待和唤醒机制。

 

系统中等待的线程在哪呢？

线程在运行的时候内存中会建立一个线程池，等待的线程（调用wait()方法）都存放在这个线程池中，当使用notify()唤醒的都是线程池中的线程，通常唤醒第一个被等待的线程，使用notifyAll()唤醒线程池中所有等待的线程

 

十分的注意：在使用wait，notify，notifyAll的时候，必须用在同步中，因为调用它们的前提是获得锁。而且必须要标志这些方法在哪个锁上调用。

为什么这些操作线程的方法要定义在Object类中呢？

因为这些方法在操作同步线程时候，都必须要标识它们所操作线程持有的锁，

只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒，也就是等待和唤醒是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

 

实例代码：

[java]  view plain copy

1. package day23;  
2.   
3. public class ThreadConnection  
4. {  
5.     public static void main(String[] args)  
6.     {  
7.     Res res = new Res();  
8.       
9.     Thread inputThread = new Thread(new InputRun(res));  
10.     Thread outputThread = new Thread(new OutputRun(res));  
11.     inputThread.start();  
12.     outputThread.start();  
13.     }  
14.   
15. }  
16. class Res  
17. {  
18.     private String name;  
19.     private String sex;  
20.     boolean flagType = true;  
21.     private boolean flagCondiction = true;  
22.     public synchronized void show()  
23.     {  
24.     if(flagCondiction)  
25.     {  
26.         try  
27.         {  
28.         this.wait();  
29.         }   
30.         catch (InterruptedException e)  
31.         {  
32.         e.printStackTrace();  
33.         }  
34.     }  
35.       
36.     System.out.println(name+".."+sex);  
37.     flagCondiction = true;  
38.     this.notifyAll();  
39.       
40.       
41.     }  
42.     public synchronized void set(String name,String sex)   
43.     {  
44.     if(!flagCondiction)  
45.     {  
46.         try  
47.         {  
48.             this.wait();    
49.         }   
50.         catch (InterruptedException e)  
51.         {  
52.             e.printStackTrace();  
53.         }  
54.     }  
55.       
56.     this.name = name;  
57.     this.sex = sex;  
58.     flagCondiction = false;  
59.     this.notifyAll();  
60.   
61.     }  
62.       
63. }  
64. class InputRun implements Runnable  
65. {  
66.     public InputRun(Res res)  
67.     {  
68.     super();  
69.     this.res = res;  
70.     }  
71.     private Res res;  
72.     public void run()  
73.     {  
74.     while(true)  
75.     {  
76.         if(res.flagType)  
77.         {  
78.         res.set("wangdabin","nan");  
79.         }  
80.         else  
81.         {  
82.           res.set("丽丽","女");  
83.         }  
84.         res.flagType = !res.flagType;  
85.     }  
86.     }  
87. }  
88. class OutputRun implements Runnable  
89. {  
90.     private Res res;  
91.     public OutputRun(Res res)  
92.     {  
93.     super();  
94.     this.res = res;  
95.     }  
96.     public void run()  
97.     {  
98.     while(true)  
99.     {  
100.        res.show();     
101.     }  
102.     }  
103. }  

当出现多个生产者和消费者时候，上述的代码会出现错误。

原因：

在一个对象调用wait()方法进入阻塞状态的时候，当另一个线程使用notify唤醒的时候，是从wait()方法之后继续执行，而不是去继续验证if中的条件。

所以必须使用while(条件),而这样又会导致所有的线程全部阻塞等待。必须使用notifyAll将所有的线程全部唤醒才能避免。

 

在jdk1.5中提供了多线程升级的解决方案：

将同步Synchronized替换成了Lock操作。

将Object中的wait，notify，notifyAll,替换成了Condition对象。

该对象用来管理那些已经获得了一个锁但是却不能做有用工作的线程，或者完成线程之间的通讯。它用来实现了因为某些条件而导致某些线程进入阻塞状态。在另一个线程中可以使用这个条件唤醒因为某一特定条件被阻塞的线程，而不是所有的线程（像Object）。

特别注意，在使用Lock锁的时候，释放锁这个动作必须要执行，无论是否抛出异常，所以有了以下的代码格式。

[java]  view plain copy

1. Lock l = ...;   
2.    l.lock();  
3.    try {  
4.        // access the resource protected by this lock  
5.    } finally {  
6.        l.unlock();//释放锁的动作一定要执行。  
7.    }  

停止线程：怎么让一个处于while(true)中的线程停止呢？

只有一种，run方法结束。

开启多线程运行，运行代码通常都是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束。

实例:

[java]  view plain copy

1. public class StopThreadDemo  
2. {  
3.     public static void main(String[] args)  
4.     {  
5.   
6.     StopThread st = new StopThread();  
7.     Thread thread = new Thread(st);  
8.     thread.start();  
9.       
10.     int num = 0;  
11.     while(true)  
12.     {  
13.         try  
14.         {  
15.         Thread.sleep(1);  
16.         }  
17.         catch (InterruptedException e)  
18.         {  
19.         // TODO Auto-generated catch block  
20.         e.printStackTrace();  
21.         }  
22.         if(num == 60)  
23.         {  
24.           
25.         st.changeFlag();  
26.         break;  
27.         }  
28.         num++;  
29.         System.out.println(num);  
30.          
31.           
32.     }  
33.     }  
34.   
35. }  
36. class StopThread implements Runnable  
37. {  
38.     private boolean flag = true;  
39.     public void changeFlag()  
40.     {  
41.     flag = false;  
42.     }  
43.     public void run()  
44.     {  
45.     while(flag)  
46.     {  
47.         System.out.println("132");  
48.     }  
49.       
50.     }  
51. }  

但是上边这种方式仅仅只能用来对于没有在代码块中出现等待使一个线程进入阻塞状态时候，就会使之不能结束，例如将上述代码块改为

[java]  view plain copy

1. public  void run()  
2.     {  
3.     synchronized(this)  
4.     {  
5.         while(flag)  
6.         {  
7.         try  
8.         {  
9.            this.wait();     
10.         }  
11.         catch(Exception e)  
12.         {  
13.         }  
14.         System.out.println("132");  
15.         }  
16.     }  
17.     }  

就会使程序不能结束，必须采取其他方法使线程结束，而不仅仅改变标记。

在Thread中有一个方法叫做interrupt(),如果在调用形如wait方法使线程进入等待状态。使用interrupt可以将其等待状态清除，重新恢复到就绪态。但是会抛出InterrupetedException.  也就是在处理这个异常的时候，将while的判断位改为false即可。

实例如下：

[java]  view plain copy

1. public class StopThreadDemo  
2. {  
3.   
4.       
5.     public static void main(String[] args)  
6.     {  
7.   
8.     StopThread st = new StopThread();  
9.     Thread thread = new Thread(st);  
10.     thread.start();  
11.       
12.     int num = 0;  
13.     while(true)  
14.     {  
15.         try  
16.         {  
17.         Thread.sleep(1);  
18.         }  
19.         catch (InterruptedException e)  
20.         {  
21.         // TODO Auto-generated catch block  
22.         e.printStackTrace();  
23.         }  
24.         if(num == 60)  
25.         {  
26.           
27. //      st.changeFlag();  
28.         thread.interrupt();  
29.         break;  
30.           
31.         }  
32.         num++;  
33.         System.out.println(num);  
34.          
35.           
36.     }  
37.     }  
38.       
39.       
40.   
41. }  
42. class StopThread implements Runnable  
43. {  
44.     private boolean flag = true;  
45.     public void changeFlag()  
46.     {  
47.     flag = false;  
48.     }  
49.     public  void run()  
50.     {  
51.     synchronized(this)  
52.     {  
53.         while(flag)  
54.         {  
55.         try  
56.         {  
57.            this.wait();     
58.         }  
59.         catch(Exception e)  
60.         {  
61.             flag = false;  
62.         }  
63.           
64.         System.out.println("132");  
65.         }  
66.     }  
67.       
68.     }  
69. }  

Thread类中的常见方法。

void   setDaemon(boolean on)

          将该线程标记为守护线程或用户线程。

当正在运行的线程都是守护线程的时候，jvm退出执行。

该方法必须在启动线程前调用。

也就是当一个线程是守护线程的时候，当用户线程没有结束时候，守护线程和它一起抢夺cpu的执行权，一旦用户线程结束，守护线程也就结束。

 

public final    void join()

                throws InterruptedException等待该线程终止。

也就是当在一个线程中调用了另一个线程的join方法时候，这个线程必须在另一个线程运行完成后才能执行。

 

static void    yield()

          暂停当前正在执行的线程对象，并执行其他线程。

 也就是临时释放这个线程的cpu执行权，使其它线程有机会执行。避免了其它线程抢不到资源而被饿死。