Java-多线程(线程池，Lock手动锁，线程的安全集合)

一、为什么要使用线程池？

线程池：该池子中预先存储若干个线程对象。整个池子就是线程池。

二、线程池的作用

 

 三、线程池的原理

四、线程池的创建方法

所有的线程池---封装了一个父接口---java.util.concurrent.Executor.

​ 它的实现接口: ExecutorService.

有一个工具类。Executors可以帮你创建相应的线程池。

[1] 创建单一线程池 newSingleThreadExecutor()

[2] 创建定长线程池。newFixedThreadPool(n);

[3] 创建可变线程池. newCachedThreadPool()

[4] 创建延迟线程池 .newScheduledThreadPool(n);

 Executor:线程池的根类。里面有一个方法。execute执行线程任务的方法Runnable类型的任务
            ExecutorService: 线程池的子接口
            shutdown(); 关闭线程池。需要等待线程池中任务执行完毕后才会关闭。
            shutdownNow(): 立即关闭线程池。
             isTerminated():判断线程池是否终止了。
             submit(): 提交任务给线程池中线程对象、Runnable和Callable类型的任务。

例子:

package com.gsh.demon_03;

import java.util.concurrent.*;

public class ExeTst {
    public static void main(String[] args) {
        /*//1.创建单一线程池
        //使用场景:队列要求线程有序执行
        ExecutorService executorService= Executors.newSingleThreadExecutor();*/
        /*//2.创建固定长度线程连接池对象
        ExecutorService executorService= Executors.newFixedThreadPool(3);*/
        /*//3.创建可变长度的线程连接池
        ExecutorService executorService=Executors.newCachedThreadPool();*/
        //4.创建延迟线程连接池
       ScheduledExecutorService executorService=Executors.newScheduledThreadPool(3);
        for (int i = 0; i <20; i++) {
            //executorService.submit()
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"************");
                }
            },10, TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

五、使用最原始的线程池

        上面讲解的使用Executors创建线程池的方式，都是使用底层ThreadPoolExecutor，而阿里开发手册，建议使用最原始的方式。

        线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

int corePoolSize, 核心线程数
          int maximumPoolSize, 最大线程数
          long keepAliveTime, 空闲时间
          TimeUnit unit, 时间单位
          BlockingQueue<Runnable> workQueue: 堵塞队列，

 

 例子:

package com.gsh.demon_04;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadExTest {
    /**
     *我们在创建线程池时尽量使用最原始的方式创建线程
     *int corePoolSize, 核心线程数
     *         int maximumPoolSize, 最大线程数
     *         long keepAliveTime, 空闲时间
     *         TimeUnit unit, 时间单位
     *         BlockingQueue<Runnable> workQueue: 堵塞队列，
     *
     */
    public static void main(String[] args) {
        //设置等待的个数，如果不设置默认是Integer最大值
        BlockingDeque blockingDeque=new LinkedBlockingDeque(3);
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,blockingDeque);
        for (int i = 0; i < 5; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"************");
                }
            });
        }
        threadPoolExecutor.shutdown();
    }
}

六、创建线程的第三种方式(实现Callable接口)

实现Callable接口，它和实现Runnable接口差不多，只是该接口种的方法有返回值和异常抛出。

Future接口:

Futrue:表示将要完成认为的结果

 

例子:

package com.gsh.demon_05;

import java.util.concurrent.*;

/**
 * @Auther: haohao
 * @Date:2022/7/1820:30
 */
class TestAdd{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
       /* //第一种方式
        //创建线程对象
        Add1 add1=new Add1();
        Add2 add2=new Add2();
        //创建FutureTask类
        FutureTask futureTask=new FutureTask(add1);//将add1封装进去
        FutureTask futureTask1=new FutureTask(add2);
        Thread  t1=new Thread(futureTask);
        Thread t2=new Thread(futureTask1);
        t1.start();
        t2.start();
        Integer integer = (Integer) futureTask.get();
        Integer integer1 = (Integer) futureTask1.get();
        System.out.println(integer+integer1);
        //自建创建线程对象并提交Callable类型的任务是比较麻烦的，需要封装到一个FutureTask类种， 建议使用线程池来提交任务
        */
        //第二种方式，使用线程池
        Add1 add1=new Add1();
        Add2 add2=new Add2();
        ExecutorService executorService=Executors.newFixedThreadPool(5);
        Future<Integer> future= executorService.submit(add1);
        Future<Integer> future1 = executorService.submit(add2);
        Integer integer = future.get();
        Integer integer1 = future1.get();//需要等线程执行完毕后，才会把结果返回给该变量
        System.out.println(integer+integer1);
    }

}
public class Add1 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 1; i <=50 ; i++) {
            sum+=i;
        }
        return sum;
    }
}
class Add2 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 51; i <=100; i++) {
            sum+=i;
        }
        return sum;
    }
}

七、手动锁 Lock接口

 

 例子：

package com.gsh.demon_06;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Auther: haohao
 * @Date:2022/7/1800:42
 */
public class Tick implements Runnable{
    static int num=100;
    //创建手动锁
    Lock suo=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                //开启手动锁
                suo.lock();
                if (num > 0) {
                    num--;
                    System.out.println(Thread.currentThread().getName() + "还剩" + num + "张票");
                } else {
                    break;
                }
            }finally {
                //关闭手动锁，释放锁
                suo.unlock();
            }

        }
    }
}

class ThreadTest_03{
    public static void main(String[] args) {
            Tick tick = new Tick();
            Thread t1 = new Thread(tick, "售票员1");
            Thread t2 = new Thread(tick, "售票员2");
            Thread t3 = new Thread(tick, "售票员3");
            Thread t4 = new Thread(tick, "售票员4");
            t1.start();
            t2.start();
            t3.start();
            t4.start();
    }
}

synchronized和Lock的区别

 九、线程的安全集合