【阳哥专栏】周末技术分活动第5期

本帖最后由就业指导－王震阳老师于 2014-8-18 11:09 编辑

活动目的：练习javaSE知识，练习查询并使用jdk自带的线程池。

活动奖励：最高3个技术分

结束时间：2014年7月21日，过期提交可能获取不到技术分！

代码提交要求：将自己的源代码压缩然后提交，提交的时候设置为管理员权限，以其他方式提交的答案无效。上交源码的时候不需要将整个工程项目压缩，只需将用到的源文件压缩即可。

题目类型：线程、线程池。

题目：老规矩，回帖领题

游客，如果您要查看本帖隐藏内容请回复

更多技术分活动：
【阳哥专栏】技术分活动第12期
http://bbs.itheima.com/thread-138162-1-1.html
【阳哥专栏】技术分活动第11期
http://bbs.itheima.com/thread-137632-1-1.html
【阳哥专栏】技术分活动第10期
http://bbs.itheima.com/thread-136866-1-1.html
【阳哥专栏】技术分活动第9期
http://bbs.itheima.com/thread-136465-1-1.html
【阳哥专栏】技术分活动第8期
http://bbs.itheima.com/thread-135781-1-1.html
【阳哥专栏】技术分活动第7期
http://bbs.itheima.com/thread-134321-1-1.html
【阳哥专栏】周末技术分活动第6期
http://bbs.itheima.com/thread-132893-1-1.html
【阳哥专栏】周末技术分活动第5期
http://bbs.itheima.com/thread-129859-1-1.html
【阳哥专栏】周末技术分活动第4期
http://bbs.itheima.com/thread-128854-1-1.html
【阳哥专栏】周末技术分活动第3期
http://bbs.itheima.com/thread-127326-1-1.html
【阳哥专栏】周末技术分活动第2期
http://bbs.itheima.com/thread-125800-1-1.html
【阳哥专栏】周末技术分派送活动第1期
http://bbs.itheima.com/thread-123979-1-1.html

王震阳老师 · 王震阳老师

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

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

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 线程池：单个线程池、固定大小的线程池、调度线程池（定时器）
* @author asus
*
*/
public class ThreadPollTest {
//测试运行
public static void main(String[] args) {
Resource res = new Resource();
// singleThreadPool(res);
// fixedThreadPool(res);
scheduledThreadPool(res);
}
//单个线程池，特点是：如果因为异常导致该线程意外终止，那么单个线程池会启动一个新的线程来代替已终止的线程，并且保证一次只启动一个线程
public static void singleThreadPool(final Resource res){
//创建一个单个线程的线程池，用于生产线程
ExecutorService producerPool = Executors.newSingleThreadExecutor();
//启动线程池，这里需要向线程池提供一个Runnable对象，加入生产方法
producerPool.execute(new Runnable(){
public void run(){
while(true){
res.produce("生产者");
}
}
});
//同样创建一个单个线程池用于消费
ExecutorService consumerPool = Executors.newSingleThreadExecutor();
//启动线程池，提供一个Runnable对象，这里启动消费方法
consumerPool.execute(new Runnable(){
public void run(){
while(true){
res.consume("消费者");
}
}
});
}
//创建一个指定大小的线程池，特点：一个固定大小的线程池，如果所有线程都处于活动状态时，在有可用线程之前，其他任务将在队列中等待
public static void fixedThreadPool(final Resource res){
//创建一个线程池，设置其中有4个可用线程
ExecutorService pool = Executors.newFixedThreadPool(4);
//内部类提供生产方法
class Producer implements Runnable{
public void run(){
while(true){
res.produce("生产者");
}
}
}
//内部类提供消费方法
class Consumer implements Runnable{
public void run(){
while(true){
res.consume("消费者");
}
}
}
//启动两个生产线程，两个消费线程
pool.execute(new Producer());
pool.execute(new Producer());
pool.execute(new Consumer());
pool.execute(new Consumer());
}
//创建可调度的线程池，特点：可以设定延迟后运行线程，或者定期执行线程
public static void scheduledThreadPool(final Resource res){
//创建一个可调度的线程池，设置其中有2个可用线程
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
//定时生产，调度线程池可以定时执行线程
pool.scheduleAtFixedRate(new Runnable(){//设置要执行的任务，这里加入生产任务
public void run(){
res.produce("生产者");
}
},
0, //设定启动延迟时间，0表示立即启动
3, //设定每个3秒执行一次
TimeUnit.SECONDS);//设定时间单位为秒
//定时消费
pool.scheduleAtFixedRate(new Runnable(){//设置要执行的任务，这里加入消费任务
public void run(){
res.consume("消费者");
}
},
2, //设定启动延迟2秒
3, //设定每个3秒执行一次
TimeUnit.SECONDS);//设定时间单位为秒
}
}
//用于多线程执行的对象，生产者消费者的生产消费方法
class Resource{
//产品数量，初始为0
private int count = 0;
//是否生产标志位，默认false，表示没有生产
private boolean isProduced = false;
//生产方法，需要和消费方法进行同步
public synchronized void produce(String name){
//判断是否已经生产，如果已经生产产品，生产者wait()，等待消费
while(isProduced){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//表示生产了一个产品
count++;
//向控制台输出生产结果
System.out.println(Thread.currentThread().getName()+"的"+name+"：生产第"+count+"个产品");
//将标志位设置成true，表示已经生产
isProduced = true;
//唤醒所有线程，避免都进入等待
this.notifyAll();
}
//消费方法，需要和生产方法进行同步
public synchronized void consume(String name){
//如果为false，表示没有产品，消费者wait()，等待生产
while(!isProduced){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//向控制台输出消费结果
System.out.println(Thread.currentThread().getName()+"的"+name+"：消费第"+count+"个产品");
//将标志位设置成false，表示已经消费
isProduced = false;
//唤醒所有线程，避免都进入等待
this.notifyAll();
}
}

复制代码

王震阳老师 · 王震阳老师

姿_`态发表于 2014-12-15 21:15
阳哥，我来看题啦啦

提交答案的时候记得提交截图。

王震阳老师 · 王震阳老师

姿_`态发表于 2014-12-16 11:20
谢谢阳哥指导

写的很好：

/*
需求：
通过查询JDK自带的线程池，学习线程池的使用方法。
并做以下练习：通过从线程池中获取的线程执行一个多线程任务（任务自定义）。
想得满分，至少得写出两种线程池的用法，并附带详细的注释。
查阅api
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池，
以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。
如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。
如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。
在某个线程被显式地关闭之前，池中的线程将一直存在。
newScheduledThreadPool
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个线程池，
它可安排在给定延迟后运行命令或者定期地执行。
参数：
corePoolSize - 池中所保存的线程数，即使线程是空闲的也包括在内。
返回：
新创建的安排线程池
思路：
1.定义一个专门用于操作线程池的类
类中定义两个方法，分别是线程池的用法
通过查阅api文档，书写线程池用噶
2.在main方法，中创建对象，调用这两个方法
*/
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
class ThreadPool
{
public static void main(String[] args)
{
ThreadPool tp = new ThreadPool();
tp.fixedThreadPool();
try{Thread.sleep(1000);}catch(Exception e){}
tp.scheduledThreadPool();
}
public void fixedThreadPool(){
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);//创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。这里设定的线程数是2
for (int i = 0; i < 8; i++) {
final int number = i;
fixedThreadPool.execute(new Runnable() {//执行execute(Runnable command) 在将来某个时间执行给定任务。任务代码如下run方法中
public void run() {
try {
System.out.println("fixedThreadPool..两个一起执行"+number);
Thread.sleep(1000);
} catch (InterruptedException e) {
fixedThreadPool.shutdown();
e.printStackTrace();
}
}
});
}
}
public void scheduledThreadPool(){
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);// 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。这里延迟的时间设为1
for (int i = 0; i < 8; i++) {
final int number = i;
scheduler.schedule(new Runnable() {//schedule(Runnable command, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的一次性操作。操作的代码如下run方法中run方法中
public void run() {
try {
System.out.println("scheduler。。等待1s在执行"+number);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}}, 3, TimeUnit.SECONDS);
}
}
}

复制代码

王震阳老师 · 王震阳老师

风祭将o 发表于 2014-12-24 23:11
今天上网看视频自学了线程池，但只是基本的了解，对于其中同步的方法不是很懂。。另外我不知道为什么当在同 ...

很给力：

package gaoxin;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
*
* 第五期
*通过查询JDK自带的线程池，学习线程池的使用方法。
*并做以下练习：通过从线程池中获取的线程执行一个多线程任务（任务自定义）。
*想得满分，至少得写出两种线程池的用法，并附带详细的注释。
**/
//自定义一个线程类，继承了Thread
class MyThread extends Thread {
int i = 0;
// 定义其中的run方法，方法是打印某线程在执行
public void run() {
while (i++ < 3)
System.out.println(this.getName() + "正在被执行。。。。。");
}
}
// 定义一个类，主要是为了让线程池执行里面的executeMethod方法。
public class ThreadPool {
//定义一个执行方法，形参接受一个线程池
public static void executeMethod(ExecutorService es) {
//让该线程池添加10个MyThread线程并执行。
for (int x : new int[5]) {
es.execute(new MyThread());
}
}
}
//我分别用三个类来测试三个线程池，是因为线程池之间会相互影响。似乎同一个类中只能同时运行一个线程池？
//单线程的线程池SingleThreadExecutor
//这种线程池里只能同时运行一个线程，如果该线程在运行中因为异常结束了，线程池会重新创建一个线程继续执行。
class SingleThread {
public static void main(String[] args) {
//定义一个单线程的线程池
ExecutorService singleThread = Executors.newSingleThreadExecutor();
//提示这是执行哪个线程池
System.out.println("这是执行singleThreadPool的结果：");
//让它执行ThreadPool类中定义的执行方法。
ThreadPool.executeMethod(singleThread);
//执行完就关闭该线程池
singleThread.shutdown();
//在打印的结果中我们可以看到，它是按顺序执行的，意味着它每次都只能同时运行一个任务。
}
}
//可重用固定数量的线程池FixedThreadPool
//这种线程池里可同时运行指定数量的线程，每完成了一个任务时就再创建一个线程去执行任务，直到线程数量达到线程池可同时运行的最大值。
class FixedThread {
public static void main(String[] args) {
//同上
ExecutorService fixedThread = Executors.newFixedThreadPool(3);
System.out.println("这是执行FixedThreadPool的结果：");
ThreadPool.executeMethod(fixedThread);
fixedThread.shutdown();
//在打印的结果中，我们可以看到，
//它在执行第一个任务后不断地创建新线程去执行余下的任务，直到线程数量达到了可允许的最大值。
//观察结果可发现，它同时执行的线程不超过3个。
}
}
//可缓存的线程池CachedThreadPool
//它也是在完成一个线程任务后再创建一个线程，但不同于fixedThreadPool的是它没有限制数量，
//它里面所能容纳的最大线程数量理论上是依据计算机内存的大小而定的。
//另外，当线程池大小超过需要运行的线程时，线程池就会回收空闲的线程。而任务增加时又将添加新线程来执行任务。
class CachedThread {
public static void main(String[] args) {
//同上
ExecutorService cachedThread = Executors.newCachedThreadPool();
System.out.println("这是执行CachedThreadPool的结果：");
ThreadPool.executeMethod(cachedThread);
cachedThread.shutdown();
//在打印的结果中，我们可以发现可缓存的线程池几乎可以同时运行所有线程。
}
}

复制代码

王震阳老师 · 王震阳老师

佛说发表于 2014-12-29 17:21
马上就要入学考试了，还差很多技术分，来领题

你的技术分已经够了呀

王震阳老师 · 王震阳老师

陈宁发表于 2015-3-10 16:24
阳哥，我来领题！

欢迎领题。

帐号		自动登录	找回密码
密码			加入黑马

【阳哥专栏】周末技术分活动第5期

220 个回复

黑马骑士勋章