多线程知识点总结

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我在在学习多线程！！！" + i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象，并调用start()方法启动线程
        new MyThread().start();

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

不建议使用：避免OOP（面向对象）单继承局限性。

2、实现Runnable接口

自定义一个MyRunnable类实现Runnable接口
实现run()方法，编写方法执行体
创建线程对象，将Runnable接口实现类当作参数传入Thread中，调用start()方法启动线程

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习多线程Runnable接口" + i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象，通过线程对象开启线程，代理
        new Thread(new MyRunnable()).start();

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

推荐使用：避免单继承局限性，灵活方便，方便同一对象被多个线程使用。

3、实现Callable接口（了解）

自定义一个MyCallable类实现Callable接口，需要返回值
重写call()方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future<Boolean> result = ser.submit(t1);
获取结果：boolean r1 = result.get();
关闭服务：ser.shutdownNow();

import java.util.concurrent.*;

public class MyCallable implements Callable<Boolean> {
    //定义火车票的数目
    private int ticketNum = 10;

    @Override
    public Boolean call() throws Exception {
            try {
                //模拟延时
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable m1 = new MyCallable();
        MyCallable m2 = new MyCallable();
        MyCallable m3 = new MyCallable();

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> f1 = ser.submit(m1);
        Future<Boolean> f2 = ser.submit(m2);
        Future<Boolean> f3 = ser.submit(m3);

        //获取结果
        boolean b1 = f1.get();
        boolean b2 = f2.get();
        boolean b3 = f3.get();

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);

        //关闭服务
        ser.shutdown();
    }
}

Callable的好处：

可以定义返回值
可以抛出异常

4、并发问题

多个线程同时操作同一个资源时，线程不安全，数据可能会发生紊乱。

用一个抢火车票的例子来说明：

//火车票抢票例子
public class MyTicket implements Runnable{
    //定义火车票的数目
    private int ticketNum = 10;
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }
            try {
                //模拟延时
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "张票");
        }
    }

    public static void main(String[] args) {
        MyTicket myTicket = new MyTicket();
        new Thread(myTicket,"张三").start();
        new Thread(myTicket,"李四").start();
        new Thread(myTicket,"黄牛").start();
    }
}

输出结果：

李四拿到了第10张票
张三拿到了第8张票
黄牛拿到了第9张票
张三拿到了第6张票
黄牛拿到了第7张票
李四拿到了第6张票
黄牛拿到了第4张票
李四拿到了第5张票
张三拿到了第3张票
张三拿到了第2张票
李四拿到了第1张票
黄牛拿到了第2张票

从输出结果中可以看出第6张、第2张票出现两次。现实中显然是不可取的。

5、静态代理

以结婚为例子，自己只负责结婚，结婚之前的现场布置和结婚之后的收尾款都由婚庆公司代理。

（1）、创建一个接口

interface Marry{
    void happyMarry();
}

（2）、创建真实角色（即谁去结婚），并实现接口

public class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("结婚了！！");
    }
}

（3）、创建代理角色（即帮助结婚），并实现接口

class WeddingCompany implements Marry{
    //代理的真实角色，通过构造方法传入
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {
        before();
        target.happyMarry();
        after();
    }

    private void after() {
        System.out.println("结婚之后，收尾款！");
    }

    private void before() {
        System.out.println("结婚之前，布置现场!");
    }
}

（4）、创建测试类

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.happyMarry();
    }
}

（5）、输出结果

结婚之前，布置现场!
结婚了！！
结婚之后，收尾款！

总结：真实对象和代理对象都要实现统一接口、代理对象要代理真实角色。

好处：代理对象可以做很多真实对象做不了的事情，真实对象就专注做自己的事。

六、Lambda表达式（其实质属于函数式编程的概念）

为什么要使用Lambda表达式：

避免匿名内部类定义过多
可以使代码看起来更简洁
去掉一堆没有意义的代码，只留下核心逻辑

理解Functional Interface（函数式接口）是学习java 8 Lambda表达式的关键所在。

函数式接口的定义：

任何接口，若只包含唯一一个抽象方法，那么它就是一个函数式接口。如Runnable接口：
```
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
```
对于函数式接口，就可以使用Lambda表达式来创建该接口的对象。

1、Lambda表达式的推导过程

（1）、创建一个函数式接口

//1、创建函数式接口
interface ILike {
    void lambda();
}

（2）、创建一个ILike接口的实现类

//2、创建ILike接口的实现类
public class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
}

（3）、测试类

public class MyLambda {
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}

结果为：

I Like Lambda

（4）、外部实现类演变为静态内部实现类

public class MyLambda {

    //3、外部实现类演变为静态内部实现类
    static class Like1 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda1");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like1();
        like.lambda();
    }
}

结果为：

I Like Lambda
I Like Lambda1

（5）、静态内部实现类演变为局部内部实现类

public class MyLambda {
    //3、外部实现类演变为静态内部实现类
    static class Like1 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda1");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like1();
        like.lambda();

        //4、静态内部实现类演变为局部内部实现类
        class Like2 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda2");
            }
        }

        like = new Like2();
        like.lambda();
    }
}

结果为：

I Like Lambda
I Like Lambda1
I Like Lambda2

（6）、局部内部实现类演变为匿名内部类

public class MyLambda {

    //3、外部实现类演变为静态内部实现类
    static class Like1 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda1");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like1();
        like.lambda();

        //4、静态内部实现类演变为局部内部实现类
        class Like2 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda2");
            }
        }

        like = new Like2();
        like.lambda();

        //5、局部内部实现类演变为匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        };
        like.lambda();
    }
}

结果为：

I Like Lambda
I Like Lambda1
I Like Lambda2
I Like Lambda3

（7）、匿名内部类演变为Lambda表达式

public class MyLambda {

    //3、外部实现类演变为静态内部实现类
    static class Like1 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I Like Lambda1");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        like = new Like1();
        like.lambda();

        //4、静态内部实现类演变为局部内部实现类
        class Like2 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I Like Lambda2");
            }
        }

        like = new Like2();
        like.lambda();

        //5、局部内部实现类演变为匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        };
        like.lambda();

        //6、匿名内部类演变为Lambda表达式
        like = () -> System.out.println("I Like Lambda4");
        like.lambda();
    }
}

结果为：

I Like Lambda
I Like Lambda1
I Like Lambda2
I Like Lambda3
I Like Lambda4

总结：

Lambda表达式使用的前提是，接口为函数式接口。

Lambda表达式只能在方法实现中有且仅有一行代码时才能去掉大括号（花括号），将其简化为一行。

示例：

//1、当方法实现时只有一行代码时：
like = () -> {
    System.out.println("I Like Lambda");
};
//可以简化为：
like = () -> System.out.println("I Like Lambda");

//2、当方法实现时有多行代码时：
like = () -> {
    System.out.println("I Like Lambda1");
    System.out.println("I Like Lambda2");
};
//则不能简化

若需要传入参数，

当传入一个参数时，可以去掉参数类型，只有去掉参数类型后才能去掉小括号；
当传入多个参数时，若要去掉参数类型，那么都要去掉，不能去掉小括号。

示例：

//无参数传入时
like = () -> System.out.println("I Like Lambda");
//传入一个参数时：三种方式均可
like = (int a) -> System.out.println("I Like Lambda" + a);
like = (a) -> System.out.println("I Like Lambda" + a);
like = a -> System.out.println("I Like Lambda" + a);
//传入多个参数时：两种方式均可
like = (int a,int b) -> System.out.println("I Like Lambda" + a + b);
like = (a,b) -> System.out.println("I Like Lambda" + a + b);

三、线程的状态

Thread thread = new Thread(); 线程对象就进入到新生状态
当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行
进入运行状态，线程才真正执行线程体的代码块
当调用sleep，wait或同步锁时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待CPU调度执行。
线程中断或结束，一旦进入死亡状态，就不能再次启动

1、线程的方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static viod sleep(long millis)	在指定毫秒内让当前正在执行的线程休眠
void join()	插队，其他线程需要等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程，别用这种方式
boolean isAlive()	测试线程是否处于活动状态

2、停止线程

不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
推荐线程自己停止下来

建议使用一个标志位进行终止变量；当flag = false时，则终止线程。示例：

public class TestStop implements Runnable{
    //1、线程中定义线程体使用标识
    private boolean flag = true;
    
    @Override
    public void run(){
        //2、线程体使用该标识
        while(flag){
            System.out.println("run...Thread");
        }
    }
    
    //3、对外提供方法改变标识
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop ).start();
        for(int i = 0;i<1000;i++){
            System.out.println("main" + i);
            if(i==900){
                //调用stop()方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

3、线程休眠

sleep（时间）指定当前线程阻塞的毫秒数。
sleep存在异常InterruptedException。
sleep时间达到后，线程进入就绪状态。
sleep可以模拟网络延时（可以放大问题的发生性），倒计时等。
每个对象都有一个锁，sleep不会释放锁。

4、线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞。
将当前线程从运行状态转换为就绪状态。
让CPU重新调度，礼让不一定成功！看CPU是否能分配到其他线程。

5、 Join合并线程

待此线程执行完毕后，再执行其他线程，其他线程阻塞。
可以想象成插队

示例：

//测试Join方法
public class TestJoin implements Runnable {

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

    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main" + i);
        }
    }
}

6、线程状态监测

Thread.State
- 线程状态。线程可以处于一下状态之一
  - NEW：未启动的线程处于此状态。
  - RUNNABLE：在Java虚拟机中执行的线程处于此状态。
  - BLOCKED：被阻塞等待监视器锁定的线程处于此状态。
  - WAITING：正在等待另一个线程执行特定动作的线程处于此状态
  - TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  - TERMINATED：已退出的线程处于此状态。
- 一个线程可以在给定的时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

7、线程的优先级

Java提供一个线程调度器来监视程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围0-1；
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
使用以下方式改变或获取优先级
- getPriority()：获取优先级。
- setPriority(int xxx)：改变优先级。

优先级的设定建议在start()调度之前。

优先级低只是意味着获取调度的概率低，并不是优先级低就不会被调用，这都是看CPU调度。

8、守护线程

线程分为守护线程和用户线程。
虚拟机必须确保用户线程执行完毕。
虚拟机不用等待守护线程执行完毕。
如：后台记录操作日志、监控内存、垃圾回收等待。

示例：

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        People people = new People();
        God god = new God();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
        thread.start();//上帝守护线程启动

        new Thread(people).start();//用户线程启动
    }
}
//人们
class People implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着！");
        }
        System.out.println("GoodBye World！");
    }
}
//上帝
class God implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("上帝保佑着你！！");
        }
    }
}

四、线程同步

并发：同一个对象被多个线程同时操作
线程同步形成的条件：队列 + 锁
由于同一进程共享同一块储存空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁（synchronized），
当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可
但是会存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程等待。
- 在多线程竞争下，加锁，释放锁会导致较多的上下文切换和调度延时，引起性能问题。
- 若一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。

1、同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要使用synchronized关键字，它包括两种用法：
- synchronized方法
- synchronized块
synchronized方法控制对对象的访问，每个对象对于一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：若将一个大的方法声明为synchronized降会影响效率。即，方法里面需要修改的内容才需要锁，锁太多会影响性能。

2、同步块：synchronized(obj){}

obj称之为同步监视器对象
- obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器对象，默认同步监视器对象为this，就是这个对象本身，或者是class
同步监视器的执行过程：
- 第一个线程访问，锁定同步监视器，执行其中的代码。
- 第二个线程访问，发现同步监视器被锁定，无法访问。
- 第一个线程访问完毕，解锁同步监视器。
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问，执行其中的代码。

3、补充JUC安全类型的包

JUC即 java.util.concurrent 包。

示例：CopyOnWriteArrayList即是安全类型的集合

public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> copyOnWriteArrayList.add(Thread.currentThread().getName())).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(copyOnWriteArrayList.size());
    }
}

结果为：

示例：ArrayList是不安全类型的集合

public class TestJU {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> list.add(Thread.currentThread().getName())).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

结果为：

//第一次
9999
//第二次
9998
//第三次
9998
//第四次
9997
//第五次
10000

4、死锁

概念：多个线程各自占有一些资源，并且互相等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的现象。如：某个同步块同时拥有两个以上对象的锁时，就可能发生死锁问题。

示例：

public class DeadLock {
    public static void main(String[] args) {
        new Thread(new Use(true, "张三")).start();
        new Thread(new Use(false, "李四")).start();
    }
}
//电脑
class Computer{}

//手机
class CellPhone{}

//使用
class Use extends Thread{

    static Computer computer = new Computer();
    static CellPhone cellPhone = new CellPhone();

    boolean choice; //选择
    String name; //使用的人

    public Use(boolean choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        use();
    }

    public void use(){
        if (choice) {
            synchronized (computer) { //获取电脑的锁
                System.out.println(this.name + "获得了电脑的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (cellPhone) { //获取手机的锁
                    System.out.println(this.name + "获得了手机的锁");
                }
            }
        } else {
            synchronized (cellPhone) { //获取手机的锁
                System.out.println(this.name + "获得了手机的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (computer) { //获取电脑的锁
                    System.out.println(this.name + "获得了电脑的锁");
                }
            }
        }
    }
}

结果：张三获取到电脑的锁后阻塞1秒，李四获取到手机的锁后阻塞1秒。阻塞结束后，张三获取到电脑的锁的同时，还想获取到手机的锁，但是手机的锁被李四拿到，同理，李四获取到手机锁的同时，想获取到电脑的锁，电脑的锁被张三拿到。就出现互相等待对方释放锁。出现死锁状态。

解决办法：将锁释放，不能同时拿两个锁。

示例：

public class DeadLock {
    public static void main(String[] args) {
        new Thread(new Use(true, "张三")).start();
        new Thread(new Use(false, "李四")).start();
    }
}
//电脑
class Computer{}

//手机
class CellPhone{}

//使用
class Use extends Thread{

    static Computer computer = new Computer();
    static CellPhone cellPhone = new CellPhone();

    boolean choice; //选择
    String name; //使用的人

    public Use(boolean choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        use();
    }

    public void use(){
        if (choice) {
            synchronized (computer) { //获取电脑的锁
                System.out.println(this.name + "获得了电脑的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (cellPhone) { //获取手机的锁
                System.out.println(this.name + "获得了手机的锁");
            }
        } else {
            synchronized (cellPhone) { //获取手机的锁
                System.out.println(this.name + "获得了手机的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (computer) { //获取电脑的锁
                System.out.println(this.name + "获得了电脑的锁");
            }
        }
    }
}

死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完成之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上述四个必要条件只需要想办法破坏其中一个或多个条件就可以避免死锁发生。

5、Lock（锁）

从JDK5.0开始，Java提供了更强大的同步机制——通过显式定义同步锁对象来实现同步。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次访问只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock（可重入锁）类实现了Lock，它拥有与synchronized相同的并发性和内存定义，在实现线程安全的控制中，比较常用的就是ReentrantLock，可以显式加锁、释放锁。

不加锁时：

public class TestLock implements Runnable{
    int ticketNum = 10;
    @Override
    public void run() {
        while (true) {
            if (ticketNum > 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(ticketNum--);
            } else {
                break;
            }
        }
    }

    public static void main(String[] args) {
        TestLock testLock = new TestLock();
        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}

结果为：

出现 -1 说明存在多个线程操作同一资源的现象

加显式锁后：

public class TestLock implements Runnable{
    int ticketNum = 10;

    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock(); //加锁
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNum--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();//解锁
            }

        }
    }

    public static void main(String[] args) {
        TestLock testLock = new TestLock();
        new Thread(testLock).start();
        new Thread(testLock).start();
        new Thread(testLock).start();
    }
}

结果为：

6、synchronized和Lock的对比

Lock是显式锁（手动开启关闭锁），synchronized是隐式锁，出了作用域自动释放。
Lock只有代码块锁，synchronized有代码块锁和方法锁。
使用Lock锁，JVM将花费较少时间来调度线程，性能更好。并且有更好的扩展性（提供更多的子类）
优先顺序：
- Lock > 同步代码块（已进入方法体，分配了相应资源） > 同步方法（在方法体外）

五、线程协作

1、生产者消费者问题

生产者和消费者共享同一个资源，并且彼此之间相互依赖，互为条件。

（1）对生产者而言，若资源还未生产完成，则需要通知消费者等待。资源生产完成之后，需要通知消费者消费。

（2）对消费者而言，在消费完成之后，需要通知生产者，已结束消费，需要生产新的资源以供消费。

（3）synchronized可以阻止并发更新同一资源实现同步，但不能实现不同线程之间的信息传递（通信），所以在生产者消费者问题中，仅有synchronized不能满足业务需求。

2、解决线程之间的通信问题

Java提供了几个方法解决线程之间的通信问题：

方法名	作用
wait()	表示线程一直等待，知道其他线程通知，与sleep()方法不同，会释放锁
wait(long timeoute)	指定等待的毫秒数
notify()	唤醒处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度

四种方法均是Object类中的方法，只能在同步方法或同步代码块中使用，否则会抛出异常。

（1）管程法

生产者：负责生产数据的模块（可以是方法、对象、线程、进程）。
消费者：负责处理数据的模块（可以是方法、对象、线程、进程）。
缓冲区：消费者不能直接使用生产者生产数据，他们之间有个缓冲区。

生产者将生产好的数据放入缓冲区，消费者从缓冲区拿数据。

下面通过一个实例帮助理解：

① 首先创建一个产品实体类

//实体类
public class Basketball{
    int id;
    public Basketball(){
        this.id = id;
    }
}

② 准备缓冲区

//缓冲区
public class Container{
    //定义一个缓冲区大小
    Basketball[] basketballs = new Basketball[10];
    //定义一个计数器
    int count = 0;
    
    //生产者生产的产品添加到缓冲区
    public synchronized void push(Basketball basketball){
        //判断计数器的值等于缓冲区的大小
        if(count == basketballs.length){
            try{
                //睡眠，等待消费者消费缓冲区产品后，唤醒通知
                this.wait();
            }catch(InterruptedException e){
                e.printStockTrace();
            }
        }
        basketballs[count] = basketball;
        count++;
        //唤醒消费者消费产品
        this.notifyAll();
    }

    //消费者消费缓冲区的产品
    public synchronized Basketball pop(){
        //判断若缓冲区中没有商品
        if(count == 0){
            try{
                //睡眠，等待生产者生产产品保存到缓冲区后，唤醒通知
                this.wait();
            }catch(InterruptedException e){
                e.printStockTrace();
            }
        }
        count--;
        Basketball basketball = baskeytballs[count];
        //唤醒生产者生产产品
        this.notifyAll();
        return basketball;
    }
}

③ 创建生产者

//生产者
public class Product extends Thread{
    //保证生产者与消费者使用同一个容器，使用构造方法赋值
    Container container;
    public Product(Container container){
        this.container = container;
    }
    @Override
    public void run(){
        for(int i = 0;i<=100;i++){
            container.push(new Basketball(i));
            System.out.println("生产了id为："+i+"的篮球");
        }
    }
}

④ 创建消费者

//消费者
public class Consumer extends Thread{
    //保证生产者与消费者使用同一个容器，使用构造方法赋值
    Container container;
    public Consumer (Container container){
        this.container = container;
    }
    @Override
    public void run(){
        for(int i = 0;i<=100;i++){
            System.out.println("消费了id为："+container.pop().id+"的篮球");
        }
    }
}

⑤ 测试类

//测试类
public class Test1(){
    public static void main(String[] args){
        //创建容器对象
        Container container = new Container();
        //启动线程
        new Product(container).start();
        new Consumer(container).start();
    }
}

（2）信号灯法（判断标志位）

①、定义一个产品类

public class TV{
    String voice; // 节目
    boolean flag = true; //标志位,若为真，则演员表演观众等待

    public synchronized void play(String voice) {
        if (!flag) {
            try {
                //阻塞，等待通知
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.voice = voice;
        System.out.println("演员正在表演:" + voice);
        this.notifyAll();
        this.flag = !this.flag;
    }

    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众正在观看:" + voice);
        this.notifyAll();
        this.flag = !this.flag;
    }

}

②、定义生产者类

//生产者
public class Player extends Thread{
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                tv.play("快乐大本营！");
            } else {
                tv.play("广告！！");
            }
        }
    }
}

③、定义消费者类

//消费者
public class Watcher extends Thread{
    TV tv ;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

④测试类

public class TestPC {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

六、线程池

背景：经常创建和销毁使用量特别大的资源时（如并发情况下的线程），对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池。可以避免频繁创建销毁，实现重复利用。
好处：
- 提高响应速度（减少创建新线程的时间）。
- 降低资源消耗（重复利用线程池中的线程，不需要每次创建）。
- 便于线程管理：
  - corePoolSize：核心池的大小。
  - maximumPoolSize：最大线程数。
  - keepAliveTime：线程没有任务时最多保持多长时间后会终止。
缺点：当线程池中的核心线程数量达标，且没有空闲线程，且等待队列已满时，再来任务，会创建非核心线程去执行新提交的任务，那么会出现，等待队列中的任务没有先执行，反而新来的任务先执行。
JDK5.0起提供了线程池相关API：
- ExecutorService：真正的线程池接口。常见的子类ThreadExecutor
  - void execute（Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable。
  - <T>Future<T>submit（Callable<T> task）：执行任务，有返回值，一般同来执行Callable。
  - void shutdown（）：关闭线程池。
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。

使用线程池创建线程：

①、创建Runnable接口实现类

public class MyPool implements Runnable{

    @Override
    public void run() {
            System.out.println(Thread.currentThread().getName());
    }
}

②、线程池创建线程

public class TestPool {
    public static void main(String[] args) {
        //1、创建服务，创建线程池
        //newFixedThreadPool 参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.execute(new MyPool());
        service.shutdown();
    }
}

测试结果为：

pool-1-thread-1
pool-1-thread-4
pool-1-thread-3
pool-1-thread-2

惨淡De笑

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

多线程知识点总结

一、线程简介

1、多任务

2、多线程

3、程序、进程、线程

4、核心概念

二、线程的创建

1、继承Thread类

2、实现Runnable接口

3、实现Callable接口（了解）

4、并发问题

5、静态代理

六、Lambda表达式（其实质属于函数式编程的概念）

1、Lambda表达式的推导过程

三、 线程的状态

1、线程的方法

2、停止线程

3、线程休眠

4、线程礼让

5、 Join合并线程

6、线程状态监测

7、线程的优先级

8、守护线程

四、线程同步

1、同步方法

2、同步块：synchronized(obj){}

3、补充JUC安全类型的包

4、死锁

5、Lock（锁）

6、synchronized和Lock的对比

五、线程协作

1、生产者消费者问题

2、解决线程之间的通信问题

（1）管程法

（2）信号灯法（判断标志位）

六、线程池

三、线程的状态