posts - 6,  comments - 0,  trackbacks - 0
java多线程(4)

线程状态：
一个线程可以处于以下几个状态：
1.新建(new):线程对象已经建立，但它还没有启动，所以它不能运行。
2.就绪(runnable):只要调度程序将时间片分配给它，它就可以运行。
3.死亡(dead):从run()方法返回。
4.阻塞(blocked):线程能够运行，但有某个条件阻止它运行，当线程处于阻塞状态，调度机制将忽略线程，不会分配给线程任何处理器时间。知道线程重新进入就绪状态。
进入阻塞状态的四个原因：
1.你通过调用sleep是线程进入休眠状态。
2.你通过调用wait()将线程挂起，知道线程得到了notify()或notifyAll()消息，线程才会进入就绪状态。
3.线程在等待某个输入/输出完成。
4.线程试图在某个对象上调用其同步控制方法，但是对象锁不可用。
下面是一个线程间合作的例子：

 1class Products {
 2    private static int i=0;
 3    private int count = ++i;
 4    public Products() {
 5        if (count == 10) {
 6            System.out.println("out of products, bye");
 7            System.exit(0);
 8        }
 9    }
10    public String toString() {return "Product" + count;}
11}
12
13class Saler extends Thread {
14    Factory f;
15    public Saler(Factory f) {
16        this.f = f;
17        start();
18    }
19    public void run() {
20        while (true) {
21            while(f.p == null) {
22                synchronized(this) {
23                    try {
24                        wait();
25                    } catch (InterruptedException e) {
26                        // TODO Auto-generated catch block
27                        e.printStackTrace();
28                    }
29                }
30            }
31            System.out.println("Saler got" + f.p);
32            f.p = null;
33        }
34    }
35}
36
37class Worker extends Thread {
38    Factory f;
39    Saler s;
40    public Worker(Factory f, Saler s) {
41        this.f = f;
42        this.s = s;
43        start();
44    }
45    public void run() {
46        while (true) {
47            if (f.p == null) {
48                f.p = new Products();
49                System.out.println("Product ready");
50                synchronized(s) {
51                    s.notify();
52                }
53            }
54            try {
55                sleep(100);
56            } catch (InterruptedException e) {
57                // TODO Auto-generated catch block
58                e.printStackTrace();
59            }
60        }
61    }
62}
63public class Factory {
64    Products p;
65    /**
66     * @param args
67     */
68    public static void main(String[] args) {
69        // TODO Auto-generated method stub
70        Factory factory = new Factory();
71        Saler saler = new Saler(factory);
72        Worker worker = new Worker(factory, saler);
73        
74    }
75
76}

以上的例子，模拟的是一个流水线，工人生产产品，销售人员提走产品，我们假设一天只要9个产品就够了。我们可以看到当Saler没有可提取的产品时，它将阻塞自己，同事释放自己的锁，当Worker对象生产出一个产品时，它将试图获得Saler对象的锁，将其唤醒，接着Saler提取走产品。运行结果如下：

Product ready
Saler gotProduct1
Product ready
Saler gotProduct2
Product ready
Saler gotProduct3
Product ready
Saler gotProduct4
Product ready
Saler gotProduct5
Product ready
Saler gotProduct6
Product ready
Saler gotProduct7
Product ready
Saler gotProduct8
Product ready
Saler gotProduct9
out of products, bye
线程间通过管道进行输入/输出：
管道在java中的对应物是PipedWriter和PipedReader.下面是一个例子：
 1import java.io.*;
 2import java.util.*;
 3
 4
 5class Worker extends Thread {
 6    private PipedWriter products = new PipedWriter();
 7    public PipedWriter getProducts() {return products;}
 8    public void run() {
 9        for (int i=0; i<10; i++) {
10            try {
11                products.write(i);
12            } catch (IOException e) {
13                // TODO Auto-generated catch block
14                e.printStackTrace();
15            }
16        }
17        try {
18            sleep(5000);
19        } catch (InterruptedException e) {
20            // TODO Auto-generated catch block
21            e.printStackTrace();
22        }
23    }
24}
25
26class Saler extends Thread {
27    private PipedReader getter;
28    public Saler(Worker worker) {
29        try {
30            this.getter = new PipedReader(worker.getProducts());
31        } catch (IOException e) {
32            // TODO Auto-generated catch block
33            e.printStackTrace();
34        }
35    }
36    public void run() {
37        int i=1;
38        while (true) {
39            
40            try {
41                System.out.println("Get produts " + (int)getter.read());
42                i++;
43                if (i>10)
44                System.exit(0);
45            } catch (IOException e) {
46                // TODO Auto-generated catch block
47                e.printStackTrace();
48            }
49        }
50    }
51}
52public class TestPipedIO {
53
54    /**
55     * @param args
56     */
57    public static void main(String[] args) {
58        // TODO Auto-generated method stub
59        Worker worker = new Worker();
60        Saler saler = new Saler(worker);
61        worker.start();
62        saler.start();
63        
64    }
65
66}
67
这个例子和上个例子类似，只是用管道实现了两个线程之间的数据传输。需要注意的是，如果在读管道的时候，管道是空的，那么将自动阻塞，就不用我们在代码中使用wait()去主动阻塞Saler进程。
运行结果如下：
Get produts 0
Get produts 1
Get produts 2
Get produts 3
Get produts 4
Get produts 5
Get produts 6
Get produts 7
Get produts 8
Get produts 9



posted on 2008-03-28 21:55 piggytommy 阅读(172) 评论(0)  编辑  收藏 所属分类: Java Basic

只有注册用户登录后才能发表评论。
网站导航:
 
Powered by:
BlogJava
Copyright ©2024 piggytommy