多线程

最新推荐文章于 2022-06-30 09:29:04 发布

goforitaaa

最新推荐文章于 2022-06-30 09:29:04 发布

阅读量82

点赞数

分类专栏：查漏补缺

本文链接：https://blog.csdn.net/goforitaaa/article/details/97615707

版权

查漏补缺专栏收录该内容

4 篇文章 0 订阅

订阅专栏

死锁分析：

在任何地方都可以线程切换，甚至在一句语句中间。

要尽量设想对自己不利的情况。

死锁条件：必须同时满足

1、互斥等待

2、 hold and wait：抢到锁缺不使用，在等待另一个锁

3、循环等待

4、无法剥夺的等待

死锁防止- ------------------------------------> 一般无法破除

破除hold and wait--------------------------->一次性获取所有资源

破除循环等待--------------------------------->按顺序获取资源

破除无法剥夺---------------------------------->加入超时

线程池：

一，线程池是什么？

线程池是一种多线程的处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行。也可以传入自己的线程工厂。

简单的来说，线程池就是一个或者多个线程的集合。一般而言，线程池有以下几个部分。

1、完成任务的一个或多个线程。

2、用于调度管理的管理线程。

3、要求执行的任务队列。

为什么要使用线程池呢？

线程池属于对象池，所有对象池都具有一个非常重要的共性，，就是为了最大程度复用对象，因为线程池最重要的特征就是利用线程。线程是个轻量的东西，但是对于互联网应用来说，如果每个用户都请求创建一个线程，那就会非常多，服务器也会难以承受众多线程去竞争cpu,不断切换，也会让cpu不断重负，很多线程将会不得不等待。

创建线程开销大

线程池：预先建立好线程，等待任务派发

派发任务的队列：先进先出的队列，线程来执行派发的任务。这些线程可以预先创建好，任务来了就不用临时创建了，立即开启服务。为了防止线程创建完就执行run()方法，让当年线程池的线程刚创建时，进入阻塞状态。等待某个任务到来。如果任务来了，就唤醒其中某一个线程，让他拿到任务去执行。

如何让线程进入阻塞状态。BlockingQueue,一个线程调用它的take()方法取数据，如果这个queue中，没有数据，线程池就会阻塞，同样一个线程调用它的put(）方法放数据，如果queue满，也会阻塞。

二、线程池参数：

corePoolSize:线程池中初始线程数量，可能处于等待状态。

maximumPoolSize:线程池中最大允许线程数量。

keepAliveTime:线程池中的线程存活时间（准确来说应该是没有任务执行时的回收时间。

unit:时间单位

workQueue:来不及执行的任务存放的阻塞队列。

handler 任务拒绝策略，当运行线程数已达到maximumPoolSize，队列也已经装满时会调用该参数拒绝任务，有默认实现。

三、线程池所对应的类为，java.util.concurrent.ThreadPoolExecutor，它在构造的时候一般需要提供池大小等参数，常用的构造方法如下：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

一个线程任务通过execute(Runnable)方法被添加到线程池，任务就是一个runnable类型对象，任务的执行方法就是runnable类型对象的run()方法。

当一个任务任务通过execute(runnable)方法添加到线程池中，有以下特点：

如果此时线程池中的数量小于 corePoolSize ,即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果线程池中的数量等于corePoolSize,但是缓冲队列未满，那么任务就被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueen满，并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize, 缓冲队列workQueen满，并且线程池中的数量等于maximumPoolSize,那么通过handler所指定的策略来处理此任务。

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool{

    private static  int produceTaskSleepTime =2000;
    public static  void main(String[] args){
        ThreadPoolExecutor  threadpool = new ThreadPoolExecutor(1,
        1,
        0,
        TimeUnit.SECONDS,
        new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        int i = 1;
        while (true){
            try{
                Thread.sleep(produceTaskSleepTime);
                String task = "task@" +i;
                System.out.println("put" + task);
                //用execute方法启动一个线程
                threadpool.execute(new ThreadPoolTask(task));
                if (i==15){
                    break;
                }
                i++;

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



    }


}
//线程类
class ThreadPoolTask implements Runnable,Serializable{
    private static final long serialVersionUid = 0;
    private static int consumTaskSleepTime =2000;
    private String threadPoolTaskData;
    ThreadPoolTask(String tasks){
        this.threadPoolTaskData = tasks;

    }
//每个任务执行过程，现在是什么都没做，除了print 和sleep
    //@Override
    public void run() {
        System.out.println("start.." + threadPoolTaskData);
        try{
            Thread.sleep(consumTaskSleepTime);
        }catch (Exception e){
            e.printStackTrace();
        }
        threadPoolTaskData = null;

    }
}

以上代码中，把所有的线程都交给一个executor来管理，把对线程的各种操作集中在一起进行管理。这样分离了业务代码和线程本身的管理代码，而且还让线程的执行效率更高且更容易管理。