《day16_多线程细节_Eclipse使用》

 1  多线程的一些细节：
 2  1，面试题：sleep方法和wait方法异同点是什么？
 3         相同点：可以让线程处于冻结状态。
 4         不同点：
 5             1，
 6                 sleep必须指定时间。
 7                 wait可以指定时间，也可以不指定时间。
 8             2，
 9                 sleep是时间到，线程处于临时阻塞或者运行。
10                 wait如果没有指定时间，必须要通过notify或者notifyAll唤醒。
11             3，
12                 sleep不一定非要定义在同步中，而wait必须要定义在同步中。
13             4，
14                 都定义在同步中，
15                 线程执行到sleep不会释放锁，
16                 线程执行到wait会释放锁。
17 synchronized(obj)
18 {
19     //sleep(5000);
20     wait();//0 1 2
21     code...
22 }
23 
24 synchronized(obj)
25 {
26     notifyAll();//3
27     code...
28 }
29  2，线程如何停止呢？
30         stop方法过时了，看描述发现，有其他解决方案。
31         线程结束，就是让线程任务代码执行完，run方法结束。
32         run方法咋结束呢？
33         run方法中通常都定义循环。只要控制住循环就可以了。
34 
35         注意：万一线程在任务中处于冻结状态，那么它还能去判断标记吗？不能！
36         咋办？通过查阅stop方法的描述，发现提供了一个解决方案。
37         文档中的解决方案：
38             如果目标线程等待很长时间（例如基于一个条件变量），
39             则应使用 interrupt 方法来中断该等待。
40             所谓的中断并不是停止线程。
41             interrupt的功能是：将线程的冻结状态清除，让线程恢复到运行状态（让线程重新具备cpu的执行资格。）
42             因为是强制性的所以会有异常发生，可以在catch中捕获异常。在异常处理中，改变标记，让循环结束。让run方法结束。
43 3，守护线程，后台线程，一般创建的都是前台线程。
44         前台后台线程运行时都是一样的，获取cpu的执行权执行。
45         只有结束的时候有些不同。
46         前台线程要通过run方法结束，线程结束。
47         后台线程也可以通过run方法结束，线程结束，还有另一种情况。
48         当进程中所有的前台线程都结束了，这时无论后台线程处于什么样的状态，都会结束，从而线程结束。
49         进程结束依赖的都是前台线程。
50 
51 4.线程的优先级：用数字标识的。 1-18
52     其中默认的初始优先级是5. 最明显的三个优先级 1 ，5 ，10.
53     setPriority(Thread.MAX_PRIORITY);
54 5,线程组：ThreadGroup.可以通过Thread的构造函数明确新线程对象所属的线程组。
55     线程组的好处，可以对多个同组线程进行统一的操作。
56     默认都属于main线程组。
57 
58 6，开发中线程的匿名内部类体现。
59

 1 //day16多线程细节&Eclipse的使用。（需求一：解决妖的问题。）
 2 
 3 /*
 4 需求：
 5 资源有姓名和性别。
 6 两个线程：
 7     一个负责给姓名和性别赋值。
 8     一个负责获取姓名和性别的值。
 9 
10 参阅ThreadTest2.java文件。
11 
12 要求：1，运行一下，解决程序中“妖”的问题。
13     分析过程：
14     加入同步，必须保证同一个锁，解决妖的问题。
15 
16 要求2：实现正确数据的间隔输出 如：
17 张飞--男
18 rose--女女女
19 张飞--男
20 rose--女女女
21 
22 要求3：对代码进行重构。
23     将name,sex私有化，资源类提供对其访问的方法。
24 
25 要求4：将程序改成JDK1.5的Lock Conditon接口。
26 
27 */
28 
29 //描述资源
30 class Resource
31 {
32     String name;
33     String sex;
34 }
35 //赋值线程任务
36 class Input implements Runnable
37 {
38     private Resource r;
39 //    private Object obj = new Object();
40     Input(Resource r)//任务一初始化就必须要处理的资源。
41     {
42         this.r = r;
43     }
44     public void run()
45     {
46         int x = 0;
47         while(true)
48         {
49             synchronized(r)
50             {
51                 if(x==0)
52                 {
53                     r.name = "张飞";
54                     r.sex = "男";
55                 }
56                 else
57                 {
58                     r.name = "rose";
59                     r.sex = "女女女";
60                 }
61             }
62             x = (x+1)%2;//实现切换。
63         }
64     }
65 }
66 //获取值线程任务。
67 class Output implements Runnable
68 {
69     private Resource r;
70 //    private Object obj = new Object();
71     Output(Resource r)
72     {
73         this.r = r;
74     }
75     public void run()
76     {
77         while(true)
78         {
79             synchronized(r)
80             {
81                 System.out.println(r.name+"...."+r.sex);
82             }
83         }
84     }
85 }
86 class ThreadTest2
87 {
88     public static void main(String[] args) 
89     {
90         Resource r = new Resource();
91         Input in = new Input(r);
92         Output out = new Output(r);
93         Thread t1 = new Thread(in);
94         Thread t2 = new Thread(out);
95         t1.start();
96         t2.start();
97     }
98 }

  1 //day16多线程细节%Eclipse的使用。（需求二：正确数据的间隔输出）
  2 /*
  3 需求：
  4 资源有姓名和性别。
  5 两个线程：
  6     一个负责给姓名和性别赋值。
  7     一个负责获取姓名和性别的值。
  8 
  9 参阅ThreadTest2.java文件。
 10 
 11 要求：1，运行一下，解决程序中“妖”的问题。
 12     分析过程：
 13     加入同步，必须保证同一个锁，解决妖的问题。
 14 
 15 要求2：实现正确数据的间隔输出 如：
 16 张飞--男
 17 rose--女女女
 18 张飞--男
 19 rose--女女女
 20 使用等待唤醒机制。
 21 wait(),notify(),notifyAll();
 22 
 23 对于等待都需要判断，定义条件
 24 
 25 
 26 
 27 要求3：对代码进行重构。
 28     将name,sex私有化，资源类提供对其访问的方法。
 29 
 30 要求4：将程序改成JDK1.5的Lock Conditon接口。
 31 
 32 */
 33 //描述资源
 34 class Resource
 35 {
 36     String name;
 37     String sex;
 38     //定义标记
 39     boolean flag=false;
 40 }
 41 //赋值线程任务
 42 class Input implements Runnable
 43 {
 44     private Resource r;
 45 //    private Object obj = new Object();
 46     Input(Resource r)//任务一初始化就必须要处理的资源。
 47     {
 48         this.r = r;
 49     }
 50     public void run()
 51     {
 52         int x = 0;
 53         while(true)
 54         {
 55             synchronized(r)
 56             {
 57                 if(r.flag)
 58                     try{r.wait();}catch(InterruptedException e){}
 59                 if(x==0)
 60                 {
 61                     r.name = "张飞";
 62                     r.sex = "男";
 63                 }
 64                 else
 65                 {
 66                     r.name = "rose";
 67                     r.sex = "女女女";
 68                 }
 69                 r.flag = true;
 70                 r.notify();
 71             }
 72             x = (x+1)%2;//实现切换。
 73         }
 74     }
 75 }
 76 //获取值线程任务。
 77 class Output implements Runnable
 78 {
 79     private Resource r;
 80 //    private Object obj = new Object();
 81     Output(Resource r)
 82     {
 83         this.r = r;
 84     }
 85     public void run()
 86     {
 87         while(true)
 88         {
 89             synchronized(r)
 90             {
 91                 if(!r.flag)
 92                     try{r.wait();}catch(InterruptedException e){}
 93                 System.out.println(r.name+"...."+r.sex);
 94                 r.flag = false;
 95                 r.notify();
 96             }
 97         }
 98     }
 99 }
100 class ThreadTest2_2
101 {
102     public static void main(String[] args) 
103     {
104         Resource r = new Resource();
105         Input in = new Input(r);
106         Output out = new Output(r);
107         Thread t1 = new Thread(in);
108         Thread t2 = new Thread(out);
109         t1.start();
110         t2.start();
111     }
112 }

  1 //day16多线程细节%Eclipse的使用。（需求二：正确数据的间隔输出）
  2 /*
  3 需求：
  4 资源有姓名和性别。
  5 两个线程：
  6     一个负责给姓名和性别赋值。
  7     一个负责获取姓名和性别的值。
  8 
  9 参阅ThreadTest2.java文件。
 10 
 11 要求：1，运行一下，解决程序中“妖”的问题。
 12     分析过程：
 13     加入同步，必须保证同一个锁，解决妖的问题。
 14 
 15 要求2：实现正确数据的间隔输出 如：
 16 张飞--男
 17 rose--女女女
 18 张飞--男
 19 rose--女女女
 20 使用等待唤醒机制。
 21 wait(),notify(),notifyAll();
 22 
 23 对于等待都需要判断，定义条件
 24 
 25 
 26 
 27 要求3：对代码进行重构。
 28     将name,sex私有化，资源类提供对其访问的方法。
 29 
 30 要求4：将程序改成JDK1.5的Lock Conditon接口。
 31 Lock替换了同步函数或者同步代码块。
 32 
 33 Condition替代了 监视器方法，将监视器方法从锁上分离出来，单独封装Condition对象。
 34 
 35 */
 36 //描述资源
 37 class Resource
 38 {
 39     private String name;
 40     private String sex;
 41     //定义标记
 42     private boolean flag=false;
 43 
 44     //赋值功能。
 45     public synchronized void set(String name,String sex)
 46     {
 47         if(flag)
 48             try{this.wait();}catch(InterruptedException e){}
 49         this.name = name;
 50         this.sex = sex;
 51         flag = true;
 52         this.notify();
 53     }
 54     //获取值。
 55     public synchronized void out()
 56     {
 57         if(!flag)
 58             try{this.wait();}catch(InterruptedException e){}
 59         System.out.println(name+"........"+sex);
 60         flag = false;
 61         this.notify();
 62     }
 63 }
 64 //赋值线程任务
 65 class Input implements Runnable
 66 {
 67     private Resource r;
 68 //    private Object obj = new Object();
 69     Input(Resource r)//任务一初始化就必须要处理的资源。
 70     {
 71         this.r = r;
 72     }
 73     public void run()
 74     {
 75         int x = 0;
 76         while(true)
 77         {
 78                 if(x==0)
 79                 {
 80                     r.set("张飞","男");
 81                 }
 82                 else
 83                 {
 84                     r.set("rose","女女女");
 85                 }
 86             x = (x+1)%2;//实现切换。
 87         }
 88     }
 89 }
 90 //获取值线程任务。
 91 class Output implements Runnable
 92 {
 93     private Resource r;
 94 //    private Object obj = new Object();
 95     Output(Resource r)
 96     {
 97         this.r = r;
 98     }
 99     public void run()
100     {
101         while(true)
102         {
103                 r.out();
104         }
105     }
106 }
107 class ThreadTest2_3
108 {
109     public static void main(String[] args) 
110     {
111         Resource r = new Resource();
112         Input in = new Input(r);
113         Output out = new Output(r);
114         Thread t1 = new Thread(in);
115         Thread t2 = new Thread(out);
116         t1.start();
117         t2.start();
118     }
119 }

  1 //day16多线程细节%Eclipse的使用。（需求二：正确数据的间隔输出）
  2 /*
  3 需求：
  4 资源有姓名和性别。
  5 两个线程：
  6     一个负责给姓名和性别赋值。
  7     一个负责获取姓名和性别的值。
  8 
  9 参阅ThreadTest2.java文件。
 10 
 11 要求：1，运行一下，解决程序中“妖”的问题。
 12     分析过程：
 13     加入同步，必须保证同一个锁，解决妖的问题。
 14 
 15 要求2：实现正确数据的间隔输出 如：
 16 张飞--男
 17 rose--女女女
 18 张飞--男
 19 rose--女女女
 20 使用等待唤醒机制。
 21 wait(),notify(),notifyAll();
 22 
 23 对于等待都需要判断，定义条件
 24 
 25 
 26 
 27 要求3：对代码进行重构。
 28     将name,sex私有化，资源类提供对其访问的方法。
 29 
 30 要求4：将程序改成JDK1.5的Lock Conditon接口。
 31 Lock替换了同步函数或者同步代码块。
 32 
 33 Condition替代了 监视器方法，将监视器方法从锁上分离出来，单独封装Condition对象。
 34 
 35 */
 36 //描述资源
 37 
 38 import java.util.concurrent.locks.*;
 39 class Resource
 40 {
 41     private String name;
 42     private String sex;
 43     //定义标记
 44     private boolean flag=false;
 45 
 46     //1.先创建锁对象。
 47     private final Lock lock = new ReentrantLock();
 48 
 49     //通过锁对象获取监视器对象。
 50     private Condition con = lock.newCondition();
 51 
 52     //赋值功能。
 53     public void set(String name,String sex)
 54     {
 55         lock.lock();
 56         try{
 57             if(flag)
 58                 try{con.await();}catch(InterruptedException e){}
 59             this.name = name;
 60             this.sex = sex;
 61             flag = true;
 62             con.signal();
 63         }finally{
 64             lock.unlock();
 65         }
 66     }
 67     //获取值。
 68     public void out()
 69     {
 70         lock.lock();
 71         try{
 72             if(!flag)
 73                 try{con.await();}catch(InterruptedException e){}
 74             System.out.println(name+"........"+sex);
 75             flag = false;
 76             con.signal();
 77         }finally{
 78             lock.unlock();
 79         }
 80     }
 81 }
 82 //赋值线程任务
 83 class Input implements Runnable
 84 {
 85     private Resource r;
 86 //    private Object obj = new Object();
 87     Input(Resource r)//任务一初始化就必须要处理的资源。
 88     {
 89         this.r = r;
 90     }
 91     public void run()
 92     {
 93         int x = 0;
 94         while(true)
 95         {
 96                 if(x==0)
 97                 {
 98                     r.set("张飞","男");
 99                 }
100                 else
101                 {
102                     r.set("rose","女女女");
103                 }
104             x = (x+1)%2;//实现切换。
105         }
106     }
107 }
108 //获取值线程任务。
109 class Output implements Runnable
110 {
111     private Resource r;
112 //    private Object obj = new Object();
113     Output(Resource r)
114     {
115         this.r = r;
116     }
117     public void run()
118     {
119         while(true)
120         {
121                 r.out();
122         }
123     }
124 }
125 class ThreadTest2_4
126 {
127     public static void main(String[] args) 
128     {
129         Resource r = new Resource();
130         Input in = new Input(r);
131         Output out = new Output(r);
132         Thread t1 = new Thread(in);
133         Thread t2 = new Thread(out);
134         t1.start();
135         t2.start();
136     }
137 }

 1 class ThreadTest 
 2 {
 3     public static void main(String[] args) 
 4     {
 5         /*
 6         new Thread(){
 7             public void run()
 8             {
 9                 for(int x=0;x<40;x++)
10                 {
11                     System.out.println(Thread.currentThread().getName()+"..X.."+x);
12                 }
13             }
14         }.start();
15         
16         Runnable r = new Runnable(){
17             public void run(){
18                     for(int x=0;x<40;x++)
19                 {
20                     System.out.println(Thread.currentThread().getName()+"..Y.."+x);
21                 }
22             }
23         };
24     
25         new Thread(r).start();
26 
27         for(int x=0;x<40;x++)
28         {
29             System.out.println(Thread.currentThread().getName()+"..Z.."+x);
30         }
31 
32         */
33         //面试题：
34         new Thread(new Runnable()
35         {
36             public void run()
37             {
38                 System.out.println("runnbable run");
39             }
40         }){
41             public void run()
42             {
43                 System.out.println("subthread run");
44             }
45         }.start();
46     }
47 }
48 
49 
50 
51 
52 /*
53 class Thread
54 {
55     private Runnable r;
56     Thread(Runnable r)
57     {
58         this.r = r;
59     }
60     public void run()
61     {
62         if(r!=null)
63         {
64             r.run();
65         }
66     }
67     public void start()
68     {
69         run();
70     }
71 }
72 
73 class SubThread extends Thread
74 {
75     public void run()
76     {
77         System.out.println("subthread run");
78     }
79 }
80 
81 Runnable r = new Runnable()
82 {
83     public void run()
84     {
85         System.out.println("runnable run");
86     }
87 }
88 
89 SubThread t = new SubThread(r);
90 t.start();
91 */

 1 //演示停止线程。
 2 class Demo implements Runnable
 3 {
 4     private boolean flag = true;
 5     public synchronized void run()
 6     {
 7         while(flag)
 8         {
 9             try
10             {
11                 wait();//t1 t2 
12             }
13             catch (InterruptedException e)
14             {
15                 System.out.println(Thread.currentThread().toString()+"..."+e.toString());
16                 changeFlag();
17             }
18             System.out.println(Thread.currentThread().getName()+"--->");
19         }
20     }
21     //对标记的修改方法。
22     public void changeFlag()
23     {
24         flag = false;
25     }
26 }
27 
28 class StopThreadDemo
29 {
30     public static void main(String[] args) 
31     {
32         Demo d = new Demo();
33 
34         Thread t1 = new Thread(d,"旺财");
35         Thread t2 = new Thread(d,"小强");
36         t1.start();
37         //将t2标记为守护线程，也叫后台线程。
38         t2.setDaemon(true);
39         t2.start();
40 
41         int x = 0;
42         while(true)
43         {
44             if(++x == 50)//条件满足。
45             {
46 //                d.changeFlag();//改变线程任务代码标记。让其他线程也结束。
47                 //强制对t1线程对象中断状态的清除。强制让其恢复到运行状态。
48                 t1.interrupt();
49                 //强制对t1线程对象中断状态的清除。强制让其恢复到运行状态。
50                 t2.interrupt();
51                 break;//跳出循环。主线程可以结束。
52             }
53             System.out.println("main------->"+x);
54         }
55         System.out.println("over");
56     }
57 }

 1 class Demo implements Runnable
 2 {
 3     public void run()
 4     {
 5         for(int x=1;x<=20;x++)
 6         {
 7             System.out.println(Thread.currentThread().getName()+"---->"+x);
 8             Thread.yield();//线程临时暂停。将执行权释放。让其他线程有机会获取。
 9         }
10     }
11 
12 }
13 class JoinThreadDemo
14 {
15     public static void main(String[] args) 
16     {
17         Demo d = new Demo();
18         Thread t1 = new Thread(d);
19         Thread t2 = new Thread(d);
20         
21         //主线程执行到这里，知道t1要加入执行，主线程释放了执行权，和执行资格，并处于冻结状态
22         //什么时候恢复呢？等待t1线程执行完。
23         t1.start();
24         t2.start();
25         //try{t1.join();}catch(InterruptedException e){}//用于临时加入一个线程，该线程运算完，程序才会继续执行。
26 
27         for(int x=1;x<=20;x++)
28         {
29             System.out.println("main------->"+x);
30         }
31         System.out.println("over");
32     }
33 }