Java多线程学习总结二

    主要讲到了interrupt方法一种让线程退出的方式、join和yield方法、线程优先级别 、线程优先级别 、线程同步、生产者消费者问题五个方面的内容。

一、interrupt方法一种让线程退出的方式。

1. import java.util.*; 
2. public class TestInterrupt{ 
3.     public static void main(String[] args){ 
4.         MyThread t = new MyThread(); 
5.         t.start(); 
6.         try{Thread.sleep(10000);} 
7.         catch(InterruptedException i){} 
8.         t.interrupt(); 
9.     } 
10. } 
11.
12. class MyThread extends Thread{ 
13.     public void run(){ 
14.         while(true){ 
15.             try{ 
16.                 System.out.println("------"+new Date()+"-----"); 
17.                 Thread.sleep(1000); 
18.             }catch(InterruptedException i){ 
19.                 return; 
20.             } 
21.         } 
22.     } 
23. } 



二、join和yield方法
t.join(); //t的run()方法完才会继续执行当前线程方法体
//也就是两个线程变成了一个线程
t.yield(); //暂停当前正在执行的线程对象，并执行其他线程。方法为静态
//哪个线程体执行此方法，哪个线程让步

1. public class TestYield { 
2.   public static void main(String[] args) { 
3.     MyThread3 t1 = new MyThread3("t1"); 
4.     MyThread3 t2 = new MyThread3("t2"); 
5.     t1.start(); t2.start(); 
6.   } 
7. } 
8. class MyThread3 extends Thread { 
9.   MyThread3(String s){super(s);} 
10.   public void run(){ 
11.     for(int i =1;i<=100;i++){ 
12.       System.out.println(getName()+": "+i); 
13.       if(i%10==0){ 
14.         yield(); 
15.       } 
16.     } 
17.   } 
18. } 

三、线程优先级别
线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级为5.
Thread.MAX_PRIORITY=1
Thread.MIN_PRIORITY=10
Thread.NORM_PRIORITY=5
例：t.setPriority(Thread.NORM_PRIORITY+3);

四、线程同步
1.同步代码块
synchronized(this){  //在执行代码块过程中，不会被其他线程打断
... 
}
public sunchronized void method //执行此方法时，当前对象被锁定
在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性，每个对象 都对应一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访 问该对象。
2.线程死锁

1. public class TestDeadLock implements Runnable { 
2.     public int flag = 1; 
3.     static Object o1 = new Object(), o2 = new Object(); 
4.     public void run() { 
5. System.out.println("flag=" + flag); 
6.         if(flag == 1) { 
7.             synchronized(o1) { 
8.                 try { 
9.                     Thread.sleep(500); 
10.                 } catch (Exception e) { 
11.                     e.printStackTrace(); 
12.                 } 
13.                 synchronized(o2) { 
14.                     System.out.println("1");     
15.                 } 
16.             } 
17.         } 
18.         if(flag == 0) { 
19.             synchronized(o2) { 
20.                 try { 
21.                     Thread.sleep(500); 
22.                 } catch (Exception e) { 
23.                     e.printStackTrace(); 
24.                 } 
25.                 synchronized(o1) { 
26.                     System.out.println("0"); 
27.                 } 
28.             } 
29.         } 
30.     }     
31.      
32.     public static void main(String[] args) { 
33.         TestDeadLock td1 = new TestDeadLock(); 
34.         TestDeadLock td2 = new TestDeadLock(); 
35.         td1.flag = 1; 
36.         td2.flag = 0; 
37.         Thread t1 = new Thread(td1); 
38.         Thread t2 = new Thread(td2); 
39.         t1.start(); 
40.         t2.start(); 
41.          
42.     } 
43. } 
五、生产者消费者问题
44. public class ProducerConsumer { 
45.     public static void main(String[] args) { 
46.         SyncStack ss = new SyncStack(); 
47.         Producer p = new Producer(ss); 
48.         Consumer c = new Consumer(ss); 
49.         new Thread(p).start(); 
50.         new Thread(p).start(); 
51.         new Thread(p).start(); 
52.         new Thread(c).start(); 
53.     } 
54. } 
55.
56. class WoTou { 
57.     int id;  
58.     WoTou(int id) { 
59.         this.id = id; 
60.     } 
61.     public String toString() { 
62.         return "WoTou : " + id; 
63.     } 
64. } 
65.
66. class SyncStack {        //栈实现 
67.     int index = 0; 
68.     WoTou[] arrWT = new WoTou[6];    //相当于装物品的篮子 
69.      
70.     public synchronized void push(WoTou wt) {    //生产物品，线程安全 
71.         while(index == arrWT.length) {        //当篮子满了线程等待 
72.             try {             
73.                 this.wait();         
74.             } catch (InterruptedException e) { 
75.                 e.printStackTrace(); 
76.             } 
77.              
78.         } 
79.         this.notifyAll();    //开始生产时，叫醒等待的其他线程开始消费 
80.         arrWT[index] = wt;     
81.         index ++; 
82.     } 
83.      
84.     public synchronized WoTou pop() {        //消费物品，线程安全 
85.         while(index == 0) {            //如果篮子空了 
86.             try { 
87.                 this.wait();        //线程等待,等待生产者开始                          
88. //生产，叫醒此线程 
89.             } catch (InterruptedException e) { 
90.                 e.printStackTrace(); 
91.             } 
92.              
93.         } 
94.         this.notifyAll();            //消费时喊醒生产者生产 
95.         index--; 
96.         return arrWT[index]; 
97.     } 
98. } 
99.
100. class Producer implements Runnable {            //生产者类 
101.     SyncStack ss = null; 
102.     Producer(SyncStack ss) { 
103.         this.ss = ss; 
104.     } 
105.      
106.     public void run() { 
107.         for(int i=0; i<20; i++) {    //生产20个 
108.             WoTou wt = new WoTou(i); 
109.             ss.push(wt);             
110.             System.out.println("生产了：" + wt); 
111.             try { 
112.                 Thread.sleep((int)(Math.random() * 200)); 
113.             } catch (InterruptedException e) { 
114.                 e.printStackTrace(); 
115.             }             
116.         } 
117.     } 
118. } 
119.
120. class Consumer implements Runnable { 
121.     SyncStack ss = null; 
122.     Consumer(SyncStack ss) { 
123.         this.ss = ss; 
124.     } 
125.      
126.     public void run() { 
127.         for(int i=0; i<20; i++) {        //消费20个 
128.             WoTou wt = ss.pop(); 
129.             System.out.println("消费了: " + wt); 
130.             try { 
131.                 Thread.sleep((int)(Math.random() * 1000)); 
132.             } catch (InterruptedException e) { 
133.                 e.printStackTrace(); 
134.             }             
135.         } 
136.     } 
137. }