多线程（java)

最新推荐文章于 2024-10-15 13:17:15 发布

核動力牛馬

最新推荐文章于 2024-10-15 13:17:15 发布

阅读量1.1k

点赞数 19

分类专栏： JAVA从入门到放弃文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_63272315/article/details/141331190

版权

JAVA从入门到放弃专栏收录该内容

10 篇文章 1 订阅

订阅专栏

1、认识线程（Thread）

1.1 概念

一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行着多份代码.

举个生活中的例子：

想象一下你去一家咖啡店点咖啡的情景。在这个例子中，我们可以将这家咖啡店看作是一个程序，而店内的工作人员则可以视为线程。

假设这家咖啡店提供两种服务：一种是现场制作咖啡，另一种是准备外卖订单。为了提高效率，咖啡店安排了两个工作人员分别负责这两项工作。

现场制作咖啡：一位工作人员专门负责为现场顾客制作咖啡。当顾客下单后，这位工作人员就开始准备咖啡，并且在完成后交给顾客。这就好比一个线程，它专注于执行一项任务，即现场咖啡的制作。
准备外卖订单：另一位工作人员则专门负责处理外卖订单。当收到外卖订单时，他会开始准备，并打包好放在取货区等待配送员取走。这也代表了一个独立的线程，它负责执行另一项任务，即外卖订单的准备。

这里有几个关键点：

共享资源：咖啡豆、牛奶等原材料是所有工作人员共用的，就像线程共享进程中的资源一样。
并发执行：两个工作人员可以同时进行各自的工作，这类似于多线程程序中的并发执行。
协调：如果原料不足，工作人员之间可能需要协调以确保工作能够顺利进行。在程序中，线程之间也需要通过锁或其他同步机制来协调对共享资源的访问。

进程和线程的区别：

资源管理：进程有独立的资源；线程共享所属进程的资源。
通信方式：进程间通信需要通过IPC机制；线程间通信直接访问共享内存。
开销：进程创建和切换开销大；线程创建和切换开销小。
并发能力：线程支持更好的并发执行。
安全性：进程提供更好的隔离和安全性。
定义：进程是系统分配资源的最小单位，线程是系统调度的最小单位。

2、创建线程

2.1 继承 Thread 类

(1) 继承 Thread 来创建一个线程类.

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线MyThread " + i);
        }
    }
}

(2) 创建 MyThread 类的实例

MyThread t = new MyThread();

(3) 调用 start 方法启动线程

t.start(); // 线程开始运行

完整代码：

package javaeeDay01.src.thread;

public class Test {

    //main方法是由一条默认的主线程负责执行的
    public static void main(String[] args)  {
        // 创建Thread线程类的对象 代表一个线程
        Thread t = new MyThread();
        // 启动线程   
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程main " + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线MyThread " + i);
        }
    }
}

方式一优缺点：

优点：编码简单

缺点：线程类已经继承Thread,无法继承其他类，不利于功能的扩展

多线程注意事项：

1、启动线程调用start方法，不是调用run方法。

2、不要将主线程放在启动子线程之前。

2.2 实现 Runnable 接口

(1) 实现 Runnable 接口

class myRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程 " + i);
        }
    }
}

(2) 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数.

 //创建任务对象
 Runnable target = new myRunnable();
 //把任务对象交给一个线程对象处理
 Thread t = new Thread(target);

(3) 调用 start 方法

t.start(); // 线程开始运行

完整代码：

package javaeeDay01.src.thread;

public class Test {


    public static void main(String[] args)  {
        //创建任务对象
        Runnable target = new myRunnable();
        //把任务对象交给一个线程对象处理
        Thread t = new Thread(target);

        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程 " + i);
        }

    }
}

class myRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程 " + i);
        }
    }
}

方式二的优缺点：

优点：任务类只是实现接口，可以继承其他类，实现其他接口，扩展性强。

缺点：可省略。

对比上面两种方法:

通常情况下，实现 Runnable 接口更常见，因为它提供了更大的灵活性，并且在大多数情况下都能满足需求。然而，如果只需要简单的线程功能并且不想引入额外的类，那么继承 Thread 类可能更为方便。

其他方式创建多线程

匿名内部类创建 Runnable 子类对象

package javaeeDay01.src.thread;

public class Test {


    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程 " + i);
                }
            }
        };

        new Thread(target).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程 " + i);
        }
    }
}

简化形式1：

package javaeeDay01.src.thread;

public class Test {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程 " + i);
                }
            }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程 " + i);
        }
    }
}

简化形式2:

package javaeeDay01.src.thread;

public class Test {
    public static void main(String[] args) {

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程 " + i);
            }
        }).start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程 " + i);
        }
    }
}

2.3 实现 Callable 接口

前两种线程创建方式都存在的一个问题

假如线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果。

怎么解决这个问题？

JDK5.O提供了Callable接口和FutureTask类来实现（多线程的第三种创建方式）。

这种方式最大的优点：可以返回线程执行完毕后的结果。

（1）创建任务对象

定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据

把Callable类型的对象封装成FutureTask（线程任务对象）。

（2）线程任务对象交给Thread对象。
（3）调用Thread对象的start方法启动线程。
（4）线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

FutureTask的API

FutureTask提供的构造器	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。

FutureTask提供的方法	说明
public V get(） throws Exception	获取线程执行call方法返回的结果。

线程创建方式三的优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。

缺点：编码复杂一点。

package javaeeDay01.Test;

import javax.swing.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test04 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建一个Callable对象
        Callable<String> call = new MyCallable(100);
        // 把Callable对象封装到FutureTask对象中
        FutureTask<String> f1 = new FutureTask<>(call);
//        未来任务对象的
//        1、是一个任务对象 实现Runnable接口
//        2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果

        // 创建一个线程对象
        new Thread(f1).start();

        //代码执行到这儿 上面线程未执行完  代码到这里会暂停 等待上面的线程执行完再获取结果

        String str =f1.get();
        System.out.println(str);


    }
}


//实现callable接口
class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "线程求出了 1-" + n + "的总和:" + sum;
    }


}

注意：调用get()时会抛出异常或者返回正确的字符串

3、Thread提供线程操作的相关方法和构造函数

Thread提供的常用方法	说明
public void run()	线程的任务方法
public void start()	启动线程
public String getName()	获取当前线程的名称，线程名称默认是Thread-索引
public void setName(String name)	为线程设置名称
public static Thread currentThread()	获取当前执行的线程对象
public static void sleep(long time)	让当前执行的线程休眠多少毫秒后，再继续执行
public final void join()...	让调用当前这个方法的线程先执行完！

Thread提供的常见构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target, String name)	封装Runnable对象成为线程对象，并指定线程名称

getName()方法：

package javaeeDay01.Test;

public class Test05 {
    public static void main(String[] args) {

        Thread t1 = new MyThread();
        t1.start();
        System.out.println(t1.getName());


//        for (int i = 1; i <= 5; i++) {
//            System.out.println("Main输出:" + i);
//        }


    }
}


class MyThread extends Thread {

//    public MyThread(String name) {
//        super(name);
//    }

    @Override
    public void run() {

        for (int i = 1; i <= 3; i++) {
            System.out.println("子线程输出:" + i);
        }
    }
}

setName方法()：

package javaeeDay01.Test;

public class Test05 {
    public static void main(String[] args) {

        Thread t1 = new MyThread();
        t1.setName("子线程1");
        t1.start();
        System.out.println(t1.getName());


//        for (int i = 1; i <= 5; i++) {
//            System.out.println("Main输出:" + i);
//        }


    }
}


class MyThread extends Thread {

//    public MyThread(String name) {
//        super(name);
//    }

    @Override
    public void run() {

        for (int i = 1; i <= 3; i++) {
            System.out.println("子线程输出:" + i);
        }
    }
}

注意：

currentThread()方法

package javaeeDay01.Test;

public class Test05 {
    public static void main(String[] args) {

        Thread t1 = new MyThread();
        t1.setName("子线程1");
        t1.start();
        System.out.println(t1.getName());

        //获取当前执行的线程对象
        Thread m = Thread.currentThread();
       //获取当前执行的线程对象的名字
        System.out.println(m.getName());
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main输出:" + i);
        }
    }
}


class MyThread extends Thread {

//    public MyThread(String name) {
//        super(name);
//    }

    @Override
    public void run() {

        for (int i = 1; i <= 3; i++) {
            System.out.println("子线程输出:" + i);
        }
    }
}

子线程1、子线程2、主线程的执行情况：

package javaeeDay01.Test;

public class Test05 {
    public static void main(String[] args) {

        Thread t1 = new MyThread();
        t1.setName("子线程1");
        t1.start();
        System.out.println(t1.getName());


        Thread t2 = new MyThread();
        t2.setName("子线程2");
        t2.start();
        System.out.println(t2.getName());

        //获取当前执行的线程对象
        Thread m = Thread.currentThread();
       //获取当前执行的线程对象的名字
        m.setName("主线程");
        System.out.println(m.getName());
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main输出:" + i);
        }
    }
}


class MyThread extends Thread {

//    public MyThread(String name) {
//        super(name);
//    }

    @Override
    public void run() {

        for (int i = 1; i <= 3; i++) {
            System.out.println("子线程输出:" + i);
        }
    }
}

使用构造器对线程名称进行命名：

package javaeeDay01.Test;

public class Test05 {
    public static void main(String[] args) {

        Thread t1 = new MyThread("子线程1");

        t1.start();
        System.out.println(t1.getName());


        Thread t2 = new MyThread("子线程2");

        t2.start();
        System.out.println(t2.getName());

        //获取当前执行的线程对象
        Thread m = Thread.currentThread();
        //获取当前执行的线程对象的名字
        m.setName("主线程");
        System.out.println(m.getName());
        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "输出:" + i);
        }
    }
}


class MyThread extends Thread {

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

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            System.out.println(t.getName() + "输出:" + i);
        }
    }
}

sleep()方法:

package javaeeDay01.Test;

public class Test06 {
    public static void main(String[] args) throws InterruptedException {

        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
            if (i == 3) {
                System.out.println("暂停五秒");
                //让当前执行的线程暂停5秒
                Thread.sleep(5000);

            }
        }
    }
}

join()方法：

package javaeeDay01.Test;

public class Test05 {
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new MyThread("子线程1");
        t1.start();
        t1.join();


        Thread t2 = new MyThread("子线程2");
        t2.start();
        t1.join();


        //获取当前执行的线程对象
        Thread m = Thread.currentThread();
        //获取当前执行的线程对象的名字
        m.setName("主线程");
        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "输出:" + i);
        }
    }
}


class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            System.out.println(t.getName() + "输出:" + i);
        }
    }
}

4、线程同步

线程同步：解决线程安全问题的方案。

线程同步的思想：让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

线程同步的常见方案：

加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

方式一：同步代码块

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

synchronized（同步锁）{
访问共享资源的核心代码
}

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

同步锁的注意事项

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

运行下列代码：

package Test2;

public class ThreadTest {
    public static void main(String[] args) {
        Account account1 = new Account("ICBC-111/", 100_000);

        new DrawThread(account1, "甲").start();
        new DrawThread(account1, "乙").start();

    }
}

package Test2;

public class DrawThread extends Thread {

    private Account account;

    public DrawThread(Account account, String name) {
        super(name);
        this.account = account;
    }

    @Override
    public void run() {
        account.drawMoney(100_000);
    }
}

package Test2;

public class Account {
    private String cardId;
    private double money;

    public Account() {
    }

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

    public static void test() {
        synchronized (Account.class) {

        }
    }

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();

        if (this.money >= money) {
            System.out.println(name + "取钱" + money + "元");
            this.money -= money;
            System.out.println(name + "取钱后余额" + this.money + "元");
        } else {
            System.out.println(name + "取钱失败 余额不足");
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

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

运行结果显然不符合逻辑。

加锁：

package Test2;

public class Account {
    private String cardId;
    private double money;

    public Account() {
    }

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

    public static void test() {
        synchronized (Account.class) {

        }
    }

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        synchronized ("锁") {
            if (this.money >= money) {
                System.out.println(name + "取钱" + money + "元");
                this.money -= money;
                System.out.println(name + "取钱后余额" + this.money + "元");
            } else {
                System.out.println(name + "取钱失败 余额不足");
            }
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

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

添加锁会产生弊端：

package Test2;

public class ThreadTest {
    public static void main(String[] args) {
        Account account1 = new Account("ICBC-111/", 100_000);

        new DrawThread(account1, "甲").start();
        new DrawThread(account1, "乙").start();

        Account account2 = new Account("ICBC-222/", 100_000);
        new DrawThread(account2, "丙").start();
        new DrawThread(account2, "丁").start();
    }
}

结果显然不符合逻辑

因为：synchronized ("锁") {} 中的”锁“ 在常量池中只有一份，此锁也会使得丙，丁无法正常串行。

解决方法：

package Test2;

public class Account {
    private String cardId;
    private double money;

    public Account() {
    }

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

    public static void test() {
        synchronized (Account.class) {
        }
    }

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        synchronized (this) {
            if (this.money >= money) {
                System.out.println(name + "取钱" + money + "元");
                this.money -= money;
                System.out.println(name + "取钱后余额" + this.money + "元");
            } else {
                System.out.println(name + "取钱失败 余额不足");
            }
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

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

甲乙线程执行此时this 代表account1

丙丁线程执行此时this 代表account2

静态方法添加锁：

对于静态方法建议使用字节码（类名.class）对象作为锁对象。

public static void test() {
        synchronized (Account.class) {
        }
    }

方式二：同步方法

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

修饰符synchronized返回值类型方法名称（形参列表）{
操作共享资源的代码
}

public synchronized void drawMoney(double money) {
        String name = Thread.currentThread().getName();

            if (this.money >= money) {
                System.out.println(name + "取钱" + money + "元");
                this.money -= money;
                System.out.println(name + "取钱后余额" + this.money + "元");
            } else {
                System.out.println(name + "取钱失败 余额不足");

        }
    }

同步代码块好还是同步方法好一点？

范围上：同步代码块锁的范围更小,性能更好，同步方法锁的范围更大，可读性更好。

方式三：Lock锁

lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。

lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。

构造器	说明
public ReentrantLock()	获得Lock锁的实现类对象

方法名称	说明
void lock()	获得锁
void unlock()	释放锁

package Test2;

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

public class Account {
    private String cardId;
    private double money;

    private final Lock lock = new ReentrantLock();

    public Account() {
    }

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

    public static void test() {
        synchronized (Account.class) {
        }
    }

    public synchronized void drawMoney(double money) {
        lock.lock();
        String name = Thread.currentThread().getName();

        if (this.money >= money) {
            System.out.println(name + "取钱" + money + "元");
            this.money -= money;
            System.out.println(name + "取钱后余额" + this.money + "元");
        } else {
            System.out.println(name + "取钱失败 余额不足");
        }
        lock.unlock();
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

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

若下图选中部分的代码执行出错解锁操作可能未执行会造成锁一直是加锁状态因此将

lock.unlock() 要放在finally()中。

public synchronized void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        lock.lock();

        try {
            if (this.money >= money) {
                System.out.println(name + "取钱" + money + "元");
                this.money -= money;
                System.out.println(name + "取钱后余额" + this.money + "元");
            } else {
                System.out.println(name + "取钱失败 余额不足");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }

5、线程通信

线程通信：多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

线程通信的常见模型（生产者与消费者模型）

生产者线程负责生产数据。

费者线程负责消费生产者生产的数据。

注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产。

Object类的等待和唤醒方法：

方法名称	说明
void wait()	让当前线程等待并释放所占锁，直到另一个线程调用 notify()方法或notilly()方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

上述方法应该使用当前同步锁对象进行调用

package Test3;

public class ThreadTest {
    public static void main(String[] args) {
        Desk desk = new Desk();

        //三个厨师线程 厨师1 厨师2 厨师3
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "大厨1").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "大厨2").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "大厨3").start();


        //吃货线程 吃货1 吃货2
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货1").start();

        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();

    }
}

package Test3;

import java.util.ArrayList;
import java.util.List;

public class Desk {
    private List<String> list = new ArrayList<>();

//    大厨做包子
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            if (list.size() == 0) {
                list.add(name + "肉包");
                System.out.println(name + "做了一个肉包");
                Thread.sleep(2000);

                //唤醒别人 等待自己
                this.notifyAll();
                this.wait();
            } else {
                this.notifyAll();
                this.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //吃货拿包子
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            if (list.size() == 1) {
                System.out.println(name + "吃了：" + list.get(0));
                list.clear();
                Thread.sleep(1000);
                this.notifyAll();
                this.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6、线程池

线程池:线程池就是一个可以复用线程的技术。

若不使用线程池，用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

JDK5.0起提供了代表线程池的接口：ExecutorService。

如何得到线程池对象？

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

ThreadPoolExecutor构造器

public ThreadPoolExecutor(
                          int corePoolSize, 
                          int maximumPoolSize, 
                          long keepAliveTime, 
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue, 
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

参数一：corePoolSize：指定线程池的核心线程的数量。 ==> 正式工：3
参数二：maximumPoolSize：指定线程池的最大线程数量。 ==> 最大员工数：5临时工：2
参数三：keepAliveTime：指定临时线程的存活时间。 ==> 临时工空闲多久被开除
参数四：unit：指定临时线程存活的时间单位（秒、分、时、天）
参数五：workQueue：指定线程池的任务队列。 ==> 客人排队的地方
参数六：threadFactory：指定线程池的线程工厂。 ==> 负责招聘员工的（hr)
参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

线程池的注意事项：

1、临时线程什么时候创建？

任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

2、什么时候会开始拒绝新任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

方法名称	说明
void execute（Runnable command)	执行Runnable任务
Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池
List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

1、线程池处理Runnable任务

执行下面代码：

package Test4;

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,
                5,
                8,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(4),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();

        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行

        pool.execute(target); //复用前面的核心线程
        pool.execute(target);
        
    }
}

package Test4;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "牛逼 666!");
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

关闭线程池：

pool.shutdown(); //1、等待线程池的任务全部执行完后，关闭线程池

pool.shutdownNow();//2、立即关闭线程池，并中断正在执行的任务

创建临时线程：

package Test4;

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,
                5,
                8,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(4),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();

        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //复用前面的核心线程
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        //临时线程
        pool.execute(target);


//        pool.shutdown(); //等待线程池的任务全部执行完后，关闭线程池
//        pool.shutdownNow();//立即关闭线程池，并中断正在执行的任务

    }
}

package Test4;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "牛逼 666!");
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程数超出maximumPoolSize的个数程序会抛出异常

package Test4;

import java.util.concurrent.*;

public class Test {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,
                5,
                8,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(4),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();

        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //线程池自定创建一个新线程任务，自动处理这个任务，自动执行
        pool.execute(target); //复用前面的核心线程
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        //临时线程
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);


//        pool.shutdown(); //等待线程池的任务全部执行完后，关闭线程池
//        pool.shutdownNow();//立即关闭线程池，并中断正在执行的任务

    }
}

package Test4;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "牛逼 666!");
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

新任务拒绝策略:

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛RejectedExecutionException异常。是是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.Discard0ldestPolicy	抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run0方法从而绕过线程池直接执行

2、线程池处理Callable任务

ExecutorService的常用方法

方法名称	说明
void execute(μnnable command)	执行任务/命令，没有返回值，一般用来执行Runnable任务
Future<T>submit(Callable<T> task)	执行任务，返回未来任务对象获取线程结果，一般拿来执行Callable任务
void shutdown()	等任务执行完毕后关闭线程池
List<Runnable> shutdownNow()	立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

package Test4;

import java.util.concurrent.*;

public class Test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = new ThreadPoolExecutor(3,
                5,
                8,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(4),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

package Test4;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() +
                "线程求出1-" + n + "的和为：" + sum;
    }
}

Executors工具类实现线程池

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

方法名称	说明
public static ExecutorServicnewFixcdThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

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

package Test4;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //1-2 通过Executors创建一个线性池对象
        ExecutorService pool = Executors.newFixedThreadPool(3);
        // 核心线程数量配置
        // 计算密集任务  核心线程数量=CPU核数+1;
        // IO密集任务  核心线程数量=CPU核数*2;

        //2、使用线程处理Callable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

package Test4;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() +
                "线程求出1-" + n + "的和为：" + sum;
    }
}

Executors使用可能存在的陷阱

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

7、并发、并行、生命周期

进程：

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

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

进程中的多个线程其实是井发和井行执行的。

并发：

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解：

在同一个时刻上，同时有多个线程在被CPU调度执行。

线程的生命周期：

也就是线程从生到死的过程中，经历的各种状态及状态转换。
理解线程这些状态有利于提升井发编程的理解能力。

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

8、乐观锁和悲观锁

悲观锁：一上来就加锁，没有安全感。每次只能一个线程进入访问完毕后，再解锁。线程安全，性能较差。

package Test5;

public class Test1 {
//    Test5.MyRunnable@3b07d329
    public static void main(String[] args) {

        Runnable target = new MyRunnable1();

        for (int i = 1; i <= 100; i++) {
            new Thread(target).start();
        }
    }
}

package Test5;

public class MyRunnable1 implements Runnable {
    private int count = 0;

    @Override
    public  void run() {
        for (int i = 0; i < 100; i++) {

            synchronized (this) {
//                System.out.println("count ==>" + (++count));
            }
        }
    }
}

乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。线程安全，性能较好。

package Test5;

public class Test2 {
    public static void main(String[] args) {

        Runnable tagert = new MyRunnable2();

        for (int i = 1; i <= 100; i++) {
            new Thread(tagert).start();
        }
    }
}

package Test5;

import java.util.concurrent.atomic.AtomicInteger;

public class MyRunnable2 implements Runnable {

    private AtomicInteger cout = new AtomicInteger();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            synchronized (this) {
                System.out.println("count ==>" + cout.incrementAndGet());
            }
        }
    }
}

9、案例：

有100份礼品，小红，小明两人同时发送，当剩下的礼品小于10份的时候则不再送出，利用多线程模拟该过程并将线程的名称打印出来。并最后在控制台分别打印小红，小明各自送出多少分礼物。

package Test6;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Test {
    public static void main(String[] args) throws InterruptedException {

        List<String> gifts = new ArrayList<>();
        String[] giftsName = {"A", "B", "C", "D", "E"};
        Random random = new Random();
        for (int i = 0; i < 100; i++) {
            gifts.add(giftsName[random.nextInt(giftsName.length)] + (i + 1));
        }

        System.out.println(gifts);

        SendThread xm = new SendThread(gifts, "小明");
        SendThread xh = new SendThread(gifts, "小红");
        xm.start();
        xh.start();

        xm.join();
        xh.join();

        System.out.println(xm.getCount());

        System.out.println(xh.getCount());
    }
}

package Test6;

import java.util.List;
import java.util.Random;

public class SendThread extends Thread {
    private List<String> gifts;

    public SendThread(List<String> gifts, String name) {
        super(name);
        this.gifts = gifts;
    }

    private int count = 0;


    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        Random random = new Random();
        while (true) {
            synchronized (gifts) {
                if (gifts.size() < 10) {
                    break;
                }
                String gift = gifts.remove(random.nextInt(gifts.size()));
                System.out.println(name + "发出: " + gift);
                count++;
            }
        }
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

}