java 线程池 嵌套_Java线程池详细解释

第一章 线程池方式1.1线程池的思想

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？

在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池。1.2线程池概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

由于线程池中有很多操作都是与优化资源相关的，我们在这里就不多赘述。我们通过一张图来了解线程池的工作原理：

合理利用线程池能够带来三个好处：1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。1.3线程池的使用

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下：public static ExecutorService newFixedThreadPool(intnThreads) ：返回线程池对

象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：public Future>submit(Runnable task) :获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤：1. 创建线程池对象。2. 创建Runnable接口子类对象。(task)3. 提交Runnable接口子类对象。(take task)4. 关闭线程池(一般不做)。

Runnable实现类代码：public class MyRunnable implementsRunnable { @Overridepublic voidrun() {

System.out.println("我要一个教练");try{

Thread.sleep(2000);

}catch(InterruptedException e) { e.printStackTrace();

}

System.out.println("教练来了： " +Thread.currentThread().getName());

System.out.println("教我游泳,交完后，教练回到了游泳池");

}

}

线程池测试类：public classThreadPoolDemo {public static voidmain(String[] args) {//创建线程池对象

ExecutorService service= Executors.newFixedThreadPool(2);//包含2个

线程对象//创建Runnable实例对象

MyRunnable r= newMyRunnable();//自己创建线程对象的方式//Thread t = new Thread(r);//t.start(); ---> 调用MyRunnable中的run()//从线程池中获取线程对象,然后调用MyRunnable中的run()

service.submit(r);//再获取个线程对象，调用MyRunnable中的run() service.submit(r);

service.submit(r);//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。//将使用完的线程又归还到了线程池中//关闭线程池//service.shutdown();

}

}

Callable测试代码: Future submit(Callabletask) : 获取线程池中的某一个线程对象，并执行.

Future : 表示计算的结果.

V get() : 获取计算完成的结果。public classThreadPoolDemo2 {public static void main(String[] args) throwsException {//创建线程池对象

ExecutorService service= Executors.newFixedThreadPool(2);//包含2个线

程对象//创建Runnable实例对象

Callable c = new Callable() { @Overridepublic Double call() throwsException {returnMath.random();

}

};//从线程池中获取线程对象,然后调用Callable中的call()//Futur 调用get() 获取运算结果 System.out.println(f1.get());

Future f2 =service.submit(c);

System.out.println(f2.get());

Future f3 =service.submit(c);

System.out.println(f3.get());

}

}1.4线程池的练习

需求: 使用线程池方式执行任务,返回1-n的和

分析: 因为需要返回求和结果,所以使用Callable方式的任务

代码:public classDemo04 {public static void main(String[] args) throwsExecutionException, InterruptedException {

ExecutorService pool= Executors.newFixedThreadPool(3);

SumCallable sc= new SumCallable(100);

Future fu =pool.submit(sc);

Integer integer=fu.get();

System.out.println("结果: " +integer);

SumCallable sc2= new SumCallable(200);

Future fu2 =pool.submit(sc2);

Integer integer2=fu2.get();

System.out.println("结果: " +integer2);

pool.shutdown();

}

}

SumCallable.javapublic class SumCallable implements Callable { private intn;public SumCallable(intn) {this.n =n;

}

@Overridepublic Integer call() throwsException {//求1-n的和? int sum = 0;

for (int i = 1; i <= n; i++) { sum +=i;

}returnsum;

}

}

第二章 死锁2.1什么是死锁

在多线程程序中,使用了多把锁,造成线程之间相互等待.程序不往下走了2.2产生死锁的条件1.有多把锁 2.有多个线程 3.有同步代码块嵌套2.3死锁代码public classDemo05 {public static void main(String[] args) { MyRunnable mr = newMyRunnable();newThread(mr).start();newThread(mr).start();

}

}class MyRunnable implementsRunnable {

Object objA= newObject();

Object objB= newObject();/*嵌套1 objA

嵌套1 objB

嵌套2 objB

嵌套1 objA*/@Overridepublic voidrun() {synchronized(objA) {

System.out.println("嵌套1 objA");synchronized (objB) {//t2, objA, 拿不到B锁,等待System.out.println("嵌套1 objB");

}

}synchronized(objB) {

System.out.println("嵌套2 objB");synchronized (objA) {//t1 , objB, 拿不到A锁,等待System.out.println("嵌套2 objA");

}

}

}

}

注意:我们应该尽量避免死锁