【Java学习】多线程-线程同步方案&线程池

一、线程同步方案

1、线程安全问题

• 多线程给我们的程序带来了很大性能上的提升，但是也可能引发线程安全问题
• 线程安全问题指的是当多个线程同时操作修改同一个共享资源的时候，可能会出现的操作结果不符预期问题

2、概述

• 线程同步就是让多个线程实现先后依次访问共享资源，这样就解决了安全问题，它最常见的方案就是加锁
• 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

3、方案一：同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全。

synchronized(同步锁) {

          访问共享资源的核心代码

}

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步锁的注意事项：

• 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug
• 对于实例方法建议使用this作为锁对象
• 对于静态方法建议使用字节码（类名.class）对象作为锁对象

4、方案二：同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全。

修饰符 synchronized 返回值类型 方法名称(形参列表) {

    操作共享资源的代码

}

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

底层原理：

• 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
• 如果方法是实例方法：同步方法默认用this作为的锁对象。
• 如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

5、方案三：Lock锁

• Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大
• Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象

常用方法：

        

6、三种方法对比

二、线程池

1、概述

• 线程池就是一个可以复用线程的技术
• 它就像一个大的池子一样，里面可以放置一些线程，当需要的时候，就从里面取出来用，用完了就还回去
• 如此一来，就不必频繁的创建和销毁线程了，大大的提高了线程的利用率，提供系统的性能

线程池的工作流程：

1、任务进入线程池，先看核心线程是否满了，如果没满则创建新的核心线程
2、如果核心线程满了，查看等待队列是否满了，如果没满则进入等待队列
3、如果等待队列满了，查看线程池的线程总数是否满了，如果没满则创建新的临时线程
4、如果总线程满了，则执行拒绝策略

2、创建线程池

使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。

线程池的七个核心参数：

• 参数一：corePoolSize : 指定线程池的核心线程的数量                          
• 参数二：maximumPoolSize：指定线程池的最大线程数量
• 参数三：keepAliveTime ：指定临时线程的存活时间
• 参数四：unit：指定临时线程存活的时间单位(秒、分、时、天）
• 参数五：workQueue：指定线程池的任务队列
• 参数六：threadFactory：指定线程池的线程工厂
• 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

任务缓冲队列：

任务拒绝策略：

3、线程池处理Runnable任务

ExecutorService的常用方法：

示例代码：

import java.util.List;
import java.util.concurrent.*;

/*
线程池执行Runnable任务
    Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
    void shutdown()  等全部任务执行完毕后，再关闭线程池！
    List<Runnable> shutdownNow() 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
*/
public class Demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
//        线程池的创建
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                3,
                5,
                60,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        System.out.println(poolExecutor);

//        执行自己的任务
        MyTask myTask = new MyTask(5);
        Future<Integer> future = poolExecutor.submit(myTask);
        Integer sum = future.get();

        MyTask myTask1 = new MyTask(10);
        Future<Integer> future1 = poolExecutor.submit(myTask1);
        Integer sum1 = future1.get();

        System.out.println(sum);
        System.out.println(sum1);

//        poolExecutor.shutdown();
        List<Runnable> runnables = poolExecutor.shutdownNow();
        System.out.println(runnables);
    }
}

//需求: 编写一个任务类, 可以通过构造器接收n, 计算并返回1~n的和
class MyTask implements Callable<Integer>{
    private int n;
    public MyTask(int n){
        this.n = n;
    }
    /**
     * 计算 1~n的和
     * @return
     * @throws Exception
     */
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return sum;
    }
}

4、线程池处理Callable任务

ExecutorService的常用方法：

5、Executors工具类实现线程池

Executors是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

 

注意事项 Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

三、补充

1、进程与线程

进程：正在运行的程序（软件）就是一个独立的进程

线程：线程是属于进程的，一个进程中可以同时运行很多个线程

2、线程的生命周期和状态

线程从生到死的过程中，经历的各种状态及状态转换，Java总共定义了6种状态

public class Thread{
     ...
     public enum State {
    	NEW, 线程刚被创建，但是并未启动
        RUNNABLE, 线程已经调用了start()，等待CPU调度
    	BLOCKED, 线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
    	WAITING, 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
        TIMED_WAITING, 同waiting状态，有几个方法（sleep,wait）有超时参数，调用他们将进入TimedWaiting状态
    	TERMINATED; 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡
    }
     ...
}

线程的6种状态互相转换：

1、线程被创建出来
2、线程调用start方法，进入就绪状态，等待cpu调度
3、抢到cpu执行权，开始执行
3-1、如果线程没有获取到锁对象，则进入阻塞状态，等获取到锁对象之后再进入就绪状态等待cpu调度
3-2、如果线程调用了wait方法则进入等待状态，等其他线程调用了notify或notifyAll方法就结束等待进入就绪状态等待调度
3-3、如果线程调用了sleep方法则进入休眠状态，释放cpu资源但不释放锁，等休眠时间结束进入就绪状态等待调度
4、执行结束，资源释放，线程死亡变为垃圾