day18_多线程

今日内容

零、复习昨日
一、作业
二、线程安全的集合
三、死锁
四、线程通信
五、线程池

零、复习昨日

见晨考

一、线程安全[重点]

1.0 线程不安全

当前线程的数据被其他线程修改

1.1 线程安全

临界资源：共享资源(同⼀个对象)，一次只可以有一个线程操作，才可以保证准确性

原子操作：不可拆分的步骤，被视作一个整体。其步骤不能打乱

线程不安全: 1) 完整的步骤可能会被破坏 2) 线程内的数据可能被别的线程修改

1.2 实现线程安全方式

同步方法
给方法加锁,即设置同步锁关键词synchronized
锁对象是当前对象,即this

同步代码块
将需要安全的代码使用同步代码块包裹,设置锁对象.
锁可以是任意对象
但是线程之前应该是同一把锁才能锁住,保证安全

其实就是给需要"同步",需要"安全",需要"步骤一致,不能打乱"的代码加锁.

需求: 要求打印机类的两个方法分别被两个线程同时执行.但是方法执行时不能被破坏,即方法执行时不能被另外一个线程抢走资源,要保证方法执行时步骤完整性.

1.2.1 同步方法

同步方法就是给方法设置synchronized关键词

注意事项:

方法要同步就都要上锁
需要同步的方法锁的得是同一个锁对象,即得是同一把锁
同步方法锁对象是this,即得是同一个this才能锁住

public class Printer {

    /**
     * 同步方法,就是给方法设置synchronized关键字
     * 同步方法锁对象是this
     * 需要同步的代码必须是同一把锁(即相同锁对象)才能保证同步,否则无效
     */
    public synchronized void print1() {
        System.out.print("1 " );
        System.out.print("2 " );
        System.out.print("3 " );
        System.out.print("4 " );
        System.out.println();
    }
    public synchronized void print2() {
        System.out.print("A " );
        System.out.print("B " );
        System.out.print("C " );
        System.out.print("D " );
        System.out.println();
    }
}

public class TestSync1 {

    public static void main(String[] args) {
        Printer printer = new Printer( );
        // 另一个对象
        // Printer printer2 = new Printer( );

        // 线程1执行打印1任务
        new Thread(){
            @Override
            public void run() {
                while (true){
                    printer.print1();
                }
            }
        }.start();

        // 线程2执行打印2任务
        new Thread(){
            @Override
            public void run() {
                while (true){

                    printer.print2();
                    // 另一个对象调用方法,虽然方法加锁了,但是锁对象不一样,没用!!!
                    // printer2.print2();
                }
            }
        }.start();
    }
}

1.2.2 同步代码块

ps: 代码块其实就是{}包裹着一段代码

同步代码块,就是使用synchronized关键词+{}包裹着的一段代码

作用: 被同步代码块包裹的代码是线程安全的,即同步,运行时是原子操作

语法: synchronized(对象){ 需要同步的代码 }

注意事项:

锁对象是任意对象
但是需要同步的方法锁对象得是同一个

public class Printer2 {
   private Object obj = new Object();
    /**
     * synchronized (锁对象){}
     * 锁对象可以是任意对象,但是需要同步的方法锁对象得是同一个
     */
    public void print1() {
        synchronized (obj){
            System.out.print("1 ");
            System.out.print("2 ");
            System.out.print("3 ");
            System.out.print("4 ");
            System.out.print("\r\n ");
        }
    }

    public void print2() {
        synchronized (obj) {
            System.out.print("A ");
            System.out.print("B ");
            System.out.print("C ");
            System.out.print("D ");
            System.out.print("\r\n ");
        }
    }
}

public class TestSync1 {

    public static void main(String[] args) {
        Printer2 printer = new Printer2( );
        // 线程1执行打印1任务
        new Thread(){
            @Override
            public void run() {
                while (true){
                    printer.print1();
                }
            }
        }.start();

        // 线程2执行打印2任务
        new Thread(){
            @Override
            public void run() {
                while (true){
                    printer.print2();
                }
            }
        }.start();
    }
}

1.2.3 区别

同步方法
是在方法上加synchronized,即整个方法上锁
锁对象是this
锁整个方法,锁的范围大

同步代码块
是在方法内部给局部代码添加synchronized,即局部代码上锁
锁对象是任意对象
锁部分代码,锁的范围小

总结: 同步方法会锁整个方法,同步代码块锁部分代码,如果方法内不是必须所有都同步,那么同步代码块最合适.

1.3 转账案例

需求: 假设银行账户类,属性有卡号,余额,名字 ; 另外有ATM机器,机器内能接收账户,给ATM指定取的钱数.ATM支持多线程操作.

账户类

public class Account {

    private String num;
    private double money;
    private String name;

    public Account() {
    }

    public Account(String num, double money, String name) {
        this.num = num;
        this.money = money;
        this.name = name;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

使用Runnable接口实现

public class ATM implements Runnable {
    private Account account;
    private double money;// 要取出的钱

    // 取钱动作要并发执行

    /**
     * 这里不能使用同步方法,因为创建两个线程对象
     * 两个线程对象启动线程,调用run,那么run上面的synchronized锁对象
     * 就不是同一个,锁不住,无法保证线程安全
     * ---------------------------------------
     * 换成同步代码块,保证线程运行时,synchronized()中的锁是同一个对象就行
     */
    @Override
    public /*synchronized*/ void run() {
        while (true) {
            synchronized (account) {
                // 要取的钱<=账户余额
                if (money <= account.getMoney( )) {
                    //t1,t2进

                    // t1抢到
                    // 获得线程对象
                    Thread thread = Thread.currentThread( );
                    System.out.println(thread.getName( ) + "正在取出" + money + "元");
                    // 账户余额要减少
                    double a = account.getMoney( );
                    double b = a - money;
                    account.setMoney(b);
                    // t1结束,t2抢回去

                    // t1又抢回来,取出最新值-100
                    // 获得最新余额
                    double balance = account.getMoney( );
                    System.out.println(thread.getName( )+"账户余额:" + balance);
                } else {
                    System.out.println("余额不足!");
                    break;
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace( );
                }
            }
        }
    }

    public ATM(Account account, double money) {
        this.account = account;
        this.money = money;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

public class TestATM {
    public static void main(String[] args) {
        // 来张银行卡
        Account account = new Account("666666", 1000, "张三");

        // 来一个ATM机,给设置账户,设置要取的钱
        ATM atm = new ATM(account, 100);
        // 创建线程并启动
        new Thread( atm ,"ATM1号").start();


        // 再来一个ATM机,给设置账户,设置要取的钱
        ATM atm2 = new ATM(account, 100);
        // 创建线程并启动
        new Thread( atm2 ,"ATM2号").start();
    }
}

练习: 实现继承Thread实现

1.4 火车票案例

售票: 有一个窗口类售票,总共100张票,窗口不止一个可以多个窗口同时售票. 要保证票不能卖超,不能卖重复的票

package com.qf.exercise2;
/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 售票窗口
 */
public class TicketWindow extends Thread{

    private static int ticketNum = 100;

    public TicketWindow(String name){
        super(name);
    }

    /**
     * 售票功能,需要并行操作(多个窗口同时售卖)
     */
    @Override
    public void run() {
        while (true) {
            synchronized(TicketWindow.class) {
                if (ticketNum > 0) {
                    System.out.println(getName( ) + "正在售出第" + ticketNum + "张票");
                    ticketNum--;
                    // 让线程陷入阻塞,模拟出票时间
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace( );
                    }
                } else {
                    System.out.println("票已售罄!");
                    break;
                }
            }
        }
    }
}

public class TestTicket {
    public static void main(String[] args) {
        new TicketWindow("窗口[1]").start();
        new TicketWindow("窗口[2]").start();
        new TicketWindow("窗口[3]").start();
    }
}

1.5 sleep问题[重点]

非线程安全的情况下,sleep会让出系统资源,让线程执行

线程安全的情况下,即加锁的情况下(在同步方法/代码内)使用sleep,不会让出系统资源,别的线程不能执行 --> 抱着锁睡

    public static void main(String[] args) {
        new Thread( "线程1" ){
            @Override
            public void run() {

                // 加锁
                synchronized (Demo2.class) {
                    for (int i = 1; i < 1000; i++) {
                        if (i == 5) {
                            // 加锁后休眠,不释放资源
                            // 即其他线程无法执行,都处于阻塞状态
                            try {
                                Thread.sleep(5000);
                            } catch (InterruptedException e) {
                                e.printStackTrace( );
                            }
                        }
                        System.out.println(getName( ) + "--->" + i);
                    }
                }
            }
        }.start();

        new Thread( "线程2" ){
            @Override
            public void run() {
                //  // 加锁
                synchronized (Demo2.class) {
                    for (int i = 1; i < 1000; i++) {
                        System.out.println(getName( ) + "--->" + i);
                    }
                }
            }
        }.start();

    }

1.6 保证线程安全的方式

不只有synchronized同步方法可以保证线程安全,其实还有很多

ThreadLocal 线程本地变量

Volatile 共享变量

Lock 锁

ReentrantLock 重入锁

等

二、线程安全的类[了解]

ArrayList是线程不安全
Vector 是线程安全

HashMap 是线程不安全 , 快
Hashtable 是线程安全 , 慢

比HashMap安全,比Hashtable快,即安全又快的集合ConcurrentHashMap[很重要]

ConcurrentHashMap类所在包是java.util.concurrent, 是并发包,简称JUC

三、死锁[了解]

死锁是指两个或多个线程（或进程）在互相等待对方释放资源的情况下陷入无限等待的状态。每个线程都在等待其他线程所持有的资源，同时又不释放自己已经持有的资源，导致所有线程都无法继续执行下去。

互相持有对方的锁还不释放

public class MyLock {
    // 左筷子锁
    static Object zuo = new Object();
    // 右筷子锁
    static Object you = new Object();

}

  public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                synchronized (MyLock.LEFT){
                    System.out.println("女朋友拿到左筷子" );
                    synchronized (MyLock.RIGHT){
                        System.out.println("女朋友拿到右筷子-吃饭" );
                    }
                }

            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                synchronized (MyLock.RIGHT){
                    System.out.println("男朋友拿到右筷子" );
                    synchronized (MyLock.LEFT){
                        System.out.println("男朋友拿到左筷子-吃饭" );
                    }
                }

            }
        }.start();
    }

解决死锁问题的方法通常包括以下几种：

预防死锁：通过破坏死锁四个必要条件之一来预防死锁。例如，避免使用不必要的资源互斥，确保线程在申请资源时不保持已有资源，引入资源的优先级等。
避免死锁：使用资源分配算法来避免系统进入死锁状态。如银行家算法（Banker’s algorithm）。
检测与恢复：通过周期性检测系统中的死锁状态，然后采取相应的恢复措施。常用的方法是使用图论中的资源分配图（Resource Allocation Graph）进行检测，并采取抢占资源或终止某些线程的策略来解除死锁。
忽略死锁：某些情况下，可以通过对系统进行建模与分析，确定死锁发生的概率非常低，因此可以选择忽略死锁的处理。

四、线程通信[熟悉]

4.1 介绍[重要]

线程通信的前提是得保证线程安全(同步)

线程通信,就是线程之间产生联系.

即通知,例如线程A执行到一定时候会停下,同时通知另外的线程B执行,
线程B执行到一定时候,也停下,通知线程A执行

以上操作需要**Object类**的方法

wait() 让当前线程等待
notify() 唤醒一个处于等待状态的线程
notifyAll() 唤醒所有处于等待状态的线程

4.2 两个线程通信

需求: 之前打印机方法,让print1()和print2()方法交替执行

package com.qf.notify;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 通信
 */
public class Printer {

    /**
     * 打印机执行的标志
     * 此标志如果是1,说明该打印机1执行,否则打印机1停下
     * 此标志如果是2,说明该打印机2执行,否则打印机2停下
     */
    private int flag = 1;

    public synchronized void print1() throws InterruptedException {
        if (flag != 1) { // 判断不是自己执行时
            // 线程停下不执行
            // 锁对象是谁,谁去wait方法
            this.wait();
        }
        System.out.print("1 " );
        System.out.print("2 " );
        System.out.print("3 " );
        System.out.print("4 " );
        System.out.print("\r\n" );

        // 改变标志
        flag = 2;
        // 通知其他处于等待状态的线程,起来干活
        // 锁对象是谁,谁去notify方法
        this.notify();
    }

    public synchronized void print2() throws InterruptedException {
        if ( flag != 2) {
            this.wait();
        }
        System.out.print("A " );
        System.out.print("B " );
        System.out.print("C " );
        System.out.print("D " );
        System.out.print("\r\n" );

        flag = 1;
        this.notify();
    }
}

public class TestNotify {
    public static void main(String[] args) {
        Printer printer = new Printer( );

        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        printer.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace( );
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        printer.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace( );
                    }
                }
            }
        }.start();
    }
}

换用同步代码块实现

package com.qf.notify;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 通信
 */
public class Printer2 {
    Object obj = new Object();

    private int flag = 1;

    public void print1() throws InterruptedException {
        synchronized (obj) {
            if (flag != 1) { // 判断不是自己执行时
                // 线程停下不执行
                // 锁对象是谁,谁去wait方法
                obj.wait( );
            }
            System.out.print("1 ");
            System.out.print("2 ");
            System.out.print("3 ");
            System.out.print("4 ");
            System.out.print("\r\n");

            // 改变标志
            flag = 2;
            // 通知其他处于等待状态的线程,起来干活
            // 锁对象是谁,谁去notify方法
            obj.notify( );
        }
    }

    public void print2() throws InterruptedException {
        synchronized (obj) {
            if (flag != 2) {
                obj.wait( );
            }
            System.out.print("A ");
            System.out.print("B ");
            System.out.print("C ");
            System.out.print("D ");
            System.out.print("\r\n");

            flag = 1;
            obj.notify( );
        }
    }
}

总结

通信的代码(wait和notify等)需要放在同步方法或者同步代码块里面
通信的代码(wait和notify等)必须使用当前锁对象来调用

4.3 练习

创建A1 A2 两个线程,分别打印1-10,11-20,保证A1执行完再执行A2线程,A2执行完再执行A1

A1 —> 1
A2 —>11
A1 —> 2
A2 —>12

package com.qf.exercise3;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class A {

    private int flag = 1;

    public synchronized void a1() throws InterruptedException {
        for (int i = 1; i < 11; i++) {
            if (flag != 1) {
                this.wait();
            }
            System.out.println("A1 -->" + i);
            flag = 2;
            this.notify();
        }
    }

    public synchronized void a2() throws InterruptedException {
        for (int i = 11; i < 21; i++) {
            if (flag != 2) {
                this.wait();
            }
            System.out.println("A2 -->" + i);
            flag = 1;
            this.notify();
        }
    }
}

package com.qf.exercise3;

import com.qf.notify.Printer;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class TestNotify {
    public static void main(String[] args) {
        A a = new A( );
        new Thread("打印机1") {
            @Override
            public void run() {
                try {
                    a.a1( );
                } catch (InterruptedException e) {
                    e.printStackTrace( );
                }
            }
        }.start( );

        new Thread("打印机2") {
            @Override
            public void run() {
                try {
                    a.a2( );
                } catch (InterruptedException e) {
                    e.printStackTrace( );
                }
            }
        }.start( );
    }
}

4.4 总结[重要]

特殊的:

wait和notify方法需要在同步方法或者同步代码块内执行
wait和notify方法需要使用当前锁对象调用
wait会让当前线程进入等待状态,让出资源,其他线程可以执行

问:wait和sleep有什么区别?

答:

相同点:

wait和sleep都可以让当前线程进入阻塞状态

不同点

wait是Object类的方法,sleep是Thread类方法
但是wait阻塞当前线程,会让出系统资源,其他线程可执行;但是sleep阻塞当前线程,会持有锁不释放,其他线程无法执行
wait需要在同步方法或同步代码快中使用,但是sleep可以在同步或非同步都可以使用

问:为什么wait和notify方法要设计在Object类中?

答: 因为锁可以是任意对象,又因为wait和notify需要被锁对象调用,那么wait和notify方法也能被任意对象调用,所以就设计在Object类中,因为Object类是所有类的父类

总结

0 线程方法

Thread(),创建线程
Thread(String name),创建线程并设置名字
Thread(Runnable r),创建线程
Thread(Runnable r,String name),创建线程,并设置名字
start 开启线程,run()执行线程任务
sleep() 线程休眠
static currentThread() 获得当前线程对象

1什么叫线程不安全?如何保证安全?

线程并发执行,多条线程处理的是同一个任务
此时就有可能出现,一个线程在执行时,另外线程过来抢走也执行,导致再抢回来时数据不正确
简单说: 线程互相争抢,导致数据不正确
如何保证线程安全? 给执行的代码加锁,同步锁(synchronized)
一种是同步方法,锁住整个方法,范围较大
一种是同步代码块,锁住局部代码,范围较小

2什么是死锁

死锁是发生在线程安全情况下
死锁是多个线程互相持有对方的资源
且不释放

3如何实现线程通信

使用等待唤醒机制实现通信
使用方法wait,notify

4wait和sleep的区别

wait和sleep都可以让线程处于阻塞(等待)状态
在加锁情况下: wait等待时释放锁,sleep等待时不释放资源

5同步方法锁对象是谁? 一定是this

6wait和notify这些线程通信的方法,为什么设计在Object类中?

wait和notify必须写在同步方法/同步代码块内
换句话说: wait和notify用的前提是必须上锁
wait和notify还必须被锁对象调用
锁对象又可以任意对象
Object又是任意类的父类
所以必须设计在Object类

public synchronized void test(){
}

public void test(){
synchronized(锁){}
}

五、线程池[面试]

5.1 线程池概念

如果有非常多的任务需要非常多的线程来完成,每个线程的工作时间不长,就需要创建很多线程,工作完又立即销毁[线程频繁创建和销毁线程]
频繁创建和销毁线程非常消耗性能,那么线程池,就是可以创建一些线程,放在"池子"中,用的时候去池子取一个线程去使用,使用完再放回去,线程可以重用
线程池,底层其实就是集合队列,里面存储线程对象,用的时候去抽即可,就不要频繁创建线程了

使用线程池的好处是

减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资
源不足的问题。
如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存(OOM Out Of Memory)或者“过度切换”的问题
–> 以上摘自阿里官方手册

5.2 线程池原理

将任务(task)提交(submit/execute)给线程池(threadpool),由线程池分配线程,运行任务,任务结束后,线程重新放入线程池供后续线程使用

5.3 创建线程池的方式

使用线程池创建线程,执行任务

JDK提供了关于创建线程池的方式

Executors: 通过该类提供的静态方法来获得不同特点的线程池对象
newFixedThreadPool
newCachedThreadPool
newScheduledThreadPool
newSingleThreadExecutor
…

ThreadPoolExecutor: 通过submit(Runnable task) 来提交任务,执行任务

线程池执行任务时，可以采用两种方法：

execute(): 没有返回值，无法判断任务是否执行成功

submit()：会返回Future对象，通过该对象判断任务是否执行成功

线程池使用完要关闭时:

shutdown() 关闭线程池

5.4 不同特点的线程池

通过Executors调用以下静态方法获得不同特点的线程池对象

方法类型解释
newFixedThreadPool 固定大小线程池池中包含固定数目的线程，空闲线程一直保留。只有核心线程，线程数量固定，任务队列为LinkedBlockingQueue
newCachedThreadPool 动态大小的线程池,原则上无上限无核心线程，非核心线程数量无限，执行完闲置60s后回收，任务队列SynchronousQueue
newScheduledThreadPool 可以执行定时任务的线程池用于调度执行的固定线程池，执行定时或周期性任务。和弦线程数量固定，非核心线程数量无线，执行完闲置10ms后回收，任务队列为DelayedWorkQueue
newSingleThreadExecutor 单线程线程池只有一个线程的池，会顺序执行提交的任务，只有一个核心线程，无非核心线程，任务队列为LinkdBlockingQueue
newSingleThread
ScheduledExecutor 单线程定时任务线程池
newWorkStealingPool 1.8提供新的方式创建线程池

以上线程池操作在阿里java开发手册中是不建议用的…
说明：Executors 返回的线程池对象的弊端如下：
1）FixedThreadPool 和 SingleThreadPool:
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2）CachedThreadPool 和 ScheduledThreadPool:
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
-----------------------
OOM 内存溢出,即系统资源耗尽

方法	类型	解释
newFixedThreadPool	固定大小线程池	池中包含固定数目的线程，空闲线程一直保留。只有核心线程，线程数量固定，任务队列为LinkedBlockingQueue
newCachedThreadPool	动态大小的线程池,原则上无上限	无核心线程，非核心线程数量无限，执行完闲置60s后回收，任务队列SynchronousQueue
newScheduledThreadPool	可以执行定时任务的线程池	用于调度执行的固定线程池，执行定时或周期性任务。和弦线程数量固定，非核心线程数量无线，执行完闲置10ms后回收，任务队列为DelayedWorkQueue
newSingleThreadExecutor	单线程线程池	只有一个线程的池，会顺序执行提交的任务，只有一个核心线程，无非核心线程，任务队列为LinkdBlockingQueue
newSingleThread ScheduledExecutor	单线程定时任务线程池
newWorkStealingPool	1.8提供新的方式创建线程池

分别演示不同特点的线程池:

public class Demo1 {

    public static void main(String[] args) {
        show3();
    }

    // 演示可调度线程池
    public static void show3(){
        // 创建可调度线程池
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);

        // 将任务提交给线程池
        for (int i = 0; i < 5000; i++) {
            threadPool.schedule(new Runnable( ) {
                @Override
                public void run() {
                    String name = Thread.currentThread( ).getName( );
                    System.out.println(name+"-执行任务" );
                }
            },5, TimeUnit.SECONDS);
        }


        // 关闭线程池
        threadPool.shutdown();
    }

    // 演示可变大小线程池
    public static void show2(){
        // 创建可变大小,线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        // 将任务提交给线程池
        for (int i = 0; i < 5000; i++) {
            threadPool.execute(new Runnable( ) {
                @Override
                public void run() {
                    String name = Thread.currentThread( ).getName( );
                    System.out.println(name+"-执行任务" );
                }
            });
        }


        // 关闭线程池
        threadPool.shutdown();


    }

    // 演示固定大小线程池
    public static void show1(){
        // 创建固定大小(3个线程),线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        // 将任务提交给线程池
        for (int i = 0; i < 50; i++) {
            threadPool.execute(new Runnable( ) {
                @Override
                public void run() {
                    String name = Thread.currentThread( ).getName( );
                    System.out.println(name+"-执行任务" );
                }
            });
        }
       // 关闭线程池
        threadPool.shutdown();
    }
}

5.5 ThreadPoolExecutor[重要]

ThreadPoolExecutor 很重要,有7个参数

参数名解释备注
int corePoolSize 指定线程池的线程数量(核心线程数) 不能小于0
int maximumPoolSize 指定线程池可支持的最大线程数最大数量>=核心线程数
long keepAliveTime 指定临时线程的最大存活时间不能小于0
TimeUnit unit 指定存活时间的单位(秒,分,时,天) 时间单位
BlockingQueue workQueue 指定任务队列
ThreadFactory threadFactory 指定哪个线程工厂创建线程
RejectedExecutionHandler handler 指定线程忙,任务队列满的时候新任务来了怎么办?拒绝策略

这几个参数解释(某大型火锅店会例子)

核心线程数5, 即店里面的固定员工5个
最大线程数15,即突然顾客太多,5个人忙不过来,临时招聘10个人来干活
最大存活时间,即顾客不多的时候,这些临时工可以待多长时间
时间单位
任务队列10,即集合, 固定员工加上临时工还处理不了顾客,在店门口放几10张凳子
线程工厂, 如何创建出的线程? 即怎么找到的员工
拒绝策略. 当固定员工,临时工,以及门口的凳子都坐满了,不让吃了,不让排队,直接拒绝

问: 什么时候创建临时线程?
答: 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建线程

问:什么时候开始拒绝任务?
答:核心线程和临时线程都在忙,任务队列也满了,新的任务过来就会拒绝

参数名	解释	备注
int corePoolSize	指定线程池的线程数量(核心线程数)	不能小于0
int maximumPoolSize	指定线程池可支持的最大线程数	最大数量>=核心线程数
long keepAliveTime	指定临时线程的最大存活时间	不能小于0
TimeUnit unit	指定存活时间的单位(秒,分,时,天)	时间单位
BlockingQueue workQueue	指定任务队列
ThreadFactory threadFactory	指定哪个线程工厂创建线程
RejectedExecutionHandler handler	指定线程忙,任务队列满的时候新任务来了怎么办?拒绝策略

package com.qf.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class TestThreadPool {

    public static void main(String[] args) {

        /**
         * int corePoolSize, 核心线程数    - 5
         * int maximumPoolSize, 最大线程数 - 15
         * long keepAliveTime,  生存时间   - 1
         * TimeUnit unit,      时间单位     - 天
         * BlockingQueue<Runnable> workQueue,  阻塞队列 处理不及时的线程进阻塞队列
         * ThreadFactory threadFactory,   线程工厂
         * RejectedExecutionHandler handler , 拒绝策略
         */
        ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
        // 至少需要5个参数
        // new ThreadPoolExecutor(5,15,1, TimeUnit.MINUTES,queue);
        // 多1个线程工厂,可以使用最简单的默认工厂
        // new ThreadPoolExecutor(5,15,1, TimeUnit.MINUTES,queue, Executors.defaultThreadFactory());
        // 多1个拒绝策略,默认的拒绝策略是 抛出异常
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                15,
                1, TimeUnit.MINUTES,
                queue,
                Executors.defaultThreadFactory( ),
                new ThreadPoolExecutor.AbortPolicy( ));

        for (int i = 1; i < 55; i++) {
            executor.execute(new Runnable( ) {
                @Override
                public void run() {
                    Thread thread = Thread.currentThread( );
                    String name = thread.getName( );
                    System.out.println( name+"执行任务");
                }
            });
        }
        executor.shutdown();
    }
}

面试肯定会问,重点是理解,要能说出来!

六、总结

关于线程API
1) 创建线程构造方法
2) 启动线程start,运行线程任务run
3) 获得线程对象Thread.currentThread()
4) 线程休眠sleep()
----------------------
关于线程同步:
1 什么是线程不安全: 线程数据被其他线程篡改?
	为什么被篡改? 是因为当前线程执行过程中,别的线程抢走资源也执行
2 什么是线程安全: 当前线程执行时,不要让别的线程抢走资源,这样就不会篡改数据
3 如何做到? 就是给方法加锁
4 两种方案: 同步方法,同步代码块
5 注意事项: 保证锁对象是同一个
----------------------
关于通信:
1) 什么叫线程通信?
2) 如何做到的? 调用哪些方法做到...
3) wait和notify使用时有注意事项:
   是不是必须要写在同步内?
   被谁调用?
   wait和sleep有什么异同?
--------------------
了解死锁,了解其他线程安全的方式,了解jdk中线程安全的类