首页 诗词 字典 板报 句子 名言 友答 励志 学校 网站地图
当前位置: 首页 > 教程频道 > 软件管理 > 软件架构设计 >

Java多线程学习小结二

2012-08-29 
Java多线程学习总结二主要讲到了interrupt方法一种让线程退出的方式、join和yield方法、线程优先级别 、线程

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.} 

热点排行