我来领题 :lol

交题  :lol

还没学到线程池 不过很期待技术分

嘻嘻哈哈嘻嘻 发表于 2014-7-20 22:38
交题

NX！这么快，都不带看API的啊。

王老师您好，源代码如下，请批阅，谢谢！！

刚刚学习API的，希望能进11期物联云计算，鼓励下吧。。。

jzxyhjl 发表于 2014-7-15 14:16
线程池 练习的少 试试这个题

可以给大家借鉴一下，写的很好。

1. package test;
   
2. 
   
3. import java.util.concurrent.ExecutorService;
   
4. import java.util.concurrent.Executors;
   
5. import java.util.concurrent.ScheduledExecutorService;
   
6. import java.util.concurrent.TimeUnit;
   
7. /**
   
8. * 线程池：单个线程池、固定大小的线程池、调度线程池（定时器）
   
9. * @author asus
   
10. *
    
11. */
    
12. 
    
13. public class ThreadPollTest {
    
14.        
    
15.         //测试运行
    
16.         public static void main(String[] args) {
    
17.                 Resource res = new Resource();
    
18.                
    
19. //                singleThreadPool(res);
    
20. //                fixedThreadPool(res);
    
21.                 scheduledThreadPool(res);
    
22.         }
    
23.        
    
24.         //单个线程池，特点是：如果因为异常导致该线程意外终止，那么单个线程池会启动一个新的线程来代替已终止的线程，并且保证一次只启动一个线程
    
25.         public static void singleThreadPool(final Resource res){
    
26.                 //创建一个单个线程的线程池，用于生产线程
    
27.                 ExecutorService producerPool = Executors.newSingleThreadExecutor();
    
28.                 //启动线程池，这里需要向线程池提供一个Runnable对象，加入生产方法
    
29.                 producerPool.execute(new Runnable(){
    
30.                                 public void run(){
    
31.                                         while(true){
    
32.                                                 res.produce("生产者");
    
33.                                         }
    
34.                                 }
    
35.                         });
    
36.                 //同样创建一个单个线程池用于消费
    
37.                 ExecutorService consumerPool = Executors.newSingleThreadExecutor();
    
38.                 //启动线程池，提供一个Runnable对象，这里启动消费方法
    
39.                 consumerPool.execute(new Runnable(){
    
40.                                 public void run(){
    
41.                                         while(true){
    
42.                                                 res.consume("消费者");
    
43.                                         }
    
44.                                 }
    
45.                         });
    
46.         }
    
47.        
    
48.         //创建一个指定大小的线程池，特点：一个固定大小的线程池，如果所有线程都处于活动状态时，在有可用线程之前，其他任务将在队列中等待
    
49.         public static void fixedThreadPool(final Resource res){
    
50.                 //创建一个线程池，设置其中有4个可用线程
    
51.                 ExecutorService pool = Executors.newFixedThreadPool(4);
    
52.                 //内部类提供生产方法
    
53.                 class Producer implements Runnable{
    
54.                         public void run(){
    
55.                                 while(true){
    
56.                                         res.produce("生产者");
    
57.                                 }
    
58.                         }
    
59.                 }
    
60.                 //内部类提供消费方法
    
61.                 class Consumer implements Runnable{
    
62.                         public void run(){
    
63.                                 while(true){
    
64.                                         res.consume("消费者");
    
65.                                 }
    
66.                         }
    
67.                 }
    
68.                 //启动两个生产线程，两个消费线程
    
69.                 pool.execute(new Producer());
    
70.                 pool.execute(new Producer());
    
71.                 pool.execute(new Consumer());
    
72.                 pool.execute(new Consumer());
    
73.         }
    
74.        
    
75.         //创建可调度的线程池，特点：可以设定延迟后运行线程，或者定期执行线程
    
76.         public static void scheduledThreadPool(final Resource res){
    
77.                 //创建一个可调度的线程池，设置其中有2个可用线程
    
78.                 ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
    
79.                 //定时生产，调度线程池可以定时执行线程
    
80.                 pool.scheduleAtFixedRate(new Runnable(){//设置要执行的任务，这里加入生产任务
    
81.                                 public void run(){
    
82.                                         res.produce("生产者");
    
83.                                 }
    
84.                         },
    
85.                         0, //设定启动延迟时间，0表示立即启动
    
86.                         3, //设定每个3秒执行一次
    
87.                         TimeUnit.SECONDS);//设定时间单位为秒
    
88.                 //定时消费
    
89.                 pool.scheduleAtFixedRate(new Runnable(){//设置要执行的任务，这里加入消费任务
    
90.                                 public void run(){
    
91.                                         res.consume("消费者");
    
92.                                 }
    
93.                         },
    
94.                         2, //设定启动延迟2秒
    
95.                         3, //设定每个3秒执行一次
    
96.                         TimeUnit.SECONDS);//设定时间单位为秒
    
97.         }
    
98. 
    
99. }
    
100. //用于多线程执行的对象，生产者消费者的生产消费方法
     
101. class Resource{
     
102.         //产品数量，初始为0
     
103.         private int count = 0;
     
104.         //是否生产标志位，默认false，表示没有生产
     
105.         private boolean isProduced = false;
     
106.        
     
107.         //生产方法，需要和消费方法进行同步
     
108.         public synchronized void produce(String name){
     
109.                 //判断是否已经生产，如果已经生产产品，生产者wait()，等待消费
     
110.                 while(isProduced){
     
111.                         try {
     
112.                                 this.wait();
     
113.                         } catch (InterruptedException e) {
     
114.                                 e.printStackTrace();
     
115.                         }
     
116.                 }
     
117.                 //表示生产了一个产品
     
118.                 count++;
     
119.                 //向控制台输出生产结果
     
120.                 System.out.println(Thread.currentThread().getName()+"的"+name+"：生产第"+count+"个产品");
     
121.                 //将标志位设置成true，表示已经生产
     
122.                 isProduced = true;
     
123.                 //唤醒所有线程，避免都进入等待
     
124.                 this.notifyAll();
     
125.         }
     
126.         //消费方法，需要和生产方法进行同步
     
127.         public synchronized void consume(String name){
     
128.                 //如果为false，表示没有产品，消费者wait()，等待生产
     
129.                 while(!isProduced){
     
130.                         try {
     
131.                                 this.wait();
     
132.                         } catch (InterruptedException e) {
     
133.                                 e.printStackTrace();
     
134.                         }
     
135.                 }
     
136.                 //向控制台输出消费结果
     
137.                 System.out.println(Thread.currentThread().getName()+"的"+name+"：消费第"+count+"个产品");
     
138.                 //将标志位设置成false，表示已经消费
     
139.                 isProduced = false;
     
140.                 //唤醒所有线程，避免都进入等待
     
141.                 this.notifyAll();
     
142.         }
     
143. }
     

复制代码

郭可 发表于 2014-7-19 02:53
又来技术分了 好开心。。。

额 失误失误  看题没注意 。。。

交作业了啊，麻烦阳哥了

昏，不是21号截止吗，王哥上面公布答案了。。。。。

看看，手机上好像看不到

郭可 发表于 2014-7-21 15:57
额 失误失误  看题没注意 。。。

学习了，谢谢阳哥

我大阳阳哥威武 厚颜无耻 跪求技术分来了

看看题目

SurgeryThreadPool.zip (1.69 KB, 下载次数: 3)

2014-7-21 21:58 上传

点击文件名下载附件
阅读权限: 200

阳哥，多出点活动题吧，加油争取11期！

是时候上演真正的技术了！

路过进来看看

小乖乖灬浩歌 发表于 2014-7-21 21:50
我大阳阳哥威武 厚颜无耻 跪求技术分来了

线程池是个什么东东  毕老师的视频了没有说啊

11111111111111111111111111111111