21_多线程

时间：2021-03-09 09:22:03 阅读：24 评论：0 收藏：0 [点我收藏+]

1. 什么是进程

正在运行的程序, 是系统进行资源分配的基本单位
目前操作系统都是支持多进程, 可以同时执行多个进程, 通过进程ID区分
单核CPU在同一时刻, 只能运行一个进程; 宏观并行, 微观串行

2. 什么是线程

线程, 又称轻量级进程(Light Weight Process)
进程中的一条执行路径, 也是CPU的基本调度单位
一个进程由一个或多个线程组成, 彼此间完成不同的工作, 同时执行, 称为多线程

3. 进程和线程的区别

进程是操作系统资源分配的基本单位, 而线程是CPU的基本调度单位
一个程序运行后至少有一个进程
一个进程可以包含多个线程, 但是至少需要有一个线程, 否则这个进程是没有意义的
进程间不能共享数据段地址, 但同进程的线程之间可以

4. 线程的组成

任何一个线程都具有基本的组成部分:
- CPU时间片: 操作系统(OS)会为每个线程分配执行时间
- 运行数据:
  - 堆空间: 存储线程需使用的对象, 多个线程可以共享堆中的对象
  - 栈空间: 存储线程需使用的局部变量, 每个线程都拥有独立的栈
- 线程的逻辑代码

5. 线程的特点

线程抢占式执行
- 效率高
- 可防止单一线程长时间独占CPU
在单核CPU中, 宏观上同时执行, 微观上顺序执行

6. 创建线程

创建线程三种方式
1. 继承Thread类, 重写run方法
2. 实现Runnable接口
3. 实现Callable接口
获取和修改线程名称
1. 获取线程ID和线程名称
  - 在Thread的子类中调用this.getId()和this.getName
  - 使用Thread.currentThread().getId()和Thread.currentThread().getName()
2. 修改线程名称
  - 调用线程对象的setName()方法
  - 使用线程子类的构造方法赋值

方式一: 继承Thread类, 重写run方法

package com.thread.demo01;

public class MyThread extends Thread {
    
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //方式一: this.getId()获取线程Id,this.getName()获取线程名称
            //System.out.println("线程id: " + this.getId() + " 线程名称: " + this.getName() + " 子线程:......" +i);
            //方式二(推荐): Thread.currentThread() 获取当前线程
            System.out.println("线程id: " + Thread.currentThread().getId() + " 线程名称: " + Thread.currentThread().getName() + " 子线程:......" + i);
        }
    }
}

启动多个线程

package com.thread.demo01;
public class TestThread {

    public static void main(String[] args) {

        //1. 创建线程对象
        MyThread myThread = new MyThread("我的子线程1");
        //2. 启动线程,不能用run()方法
        //myThread.setName("我的子线程1"); //启动线程前设置线程名称
        myThread.start();
        System.out.println(myThread.getId());

        MyThread myThread1 = new MyThread("我的子线程2);
        //myThread1.setName("我的子线程2"); //启动线程前设置线程名称
        myThread1.start();
        System.out.println(myThread1.getId());

        //主线程执行
        for (int i = 0; i < 50; i++) {
            System.out.println("主线程:......" + i);
        }
    }
}

案例一: 实现四个窗口同时各卖票100张

public class SellTicket extends Thread{

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

    private int ticket = 100;//票

    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖的第" + (101 - ticket) + "张票");
            ticket--;
        }
    }
}

public class TestTicket {

    public static void main(String[] args) {

        //1. 创建四个卖票窗口
        SellTicket st1 = new SellTicket("窗口一");
        SellTicket st2 = new SellTicket("窗口二");
        SellTicket st3 = new SellTicket("窗口三");
        SellTicket st4 = new SellTicket("窗口四");

        //2. 开启多线程
        st1.start();
        st2.start();
        st3.start();
        st4.start();




    }
}

方式二: 实现Runnable接口

Thread的构造方法,可传入Runnable target, String name ,即Runnable接口类型的对象和字符串类型的名称

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize, AccessControlContext acc,
                  boolean inheritThreadLocals)

public class MyRunnable implements Runnable{


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

public class TestRunnable {

    public static void main(String[] args) {

        //创建MyRunnable对象, 表示线程要执行的功能
        MyRunnable runnable = new MyRunnable();

        //2. 创建线程对象
        Thread thread = new Thread(runnable, "我的线程一");
        Thread thread1 = new Thread(runnable, "我的线程二");

        //3. 启动多线程
        thread.start();
        thread1.start();

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

方式二优化: 使用匿名内部类

public class TestRunnable1 {

    public static void main(String[] args) {

        //1. 创建Runnable对象, 以及使用匿名内部类
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "子线程......" + i);
                }
            }
        };

        //2. 创建线程对象
        Thread thread = new Thread(runnable, "我的线程1");
        Thread thread1 = new Thread(runnable, "我的线程2");

        //3. 启动多线程
        thread.start();
        thread1.start();

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

    }
    
}

案例二: 实现四个窗口共同卖票100张

public class Ticket implements Runnable{

    private int ticket = 100;


    @Override
    public void run() {
        while (ticket > 0){
            System.out.println(Thread.currentThread().getName() + "售出第" + (101-ticket) + "张票");
            ticket--;
        }

    }
    
}

public class TestTicket {

    public static void main(String[] args) {

        Ticket ticket = new Ticket();

        Thread wd1 = new Thread(ticket, "窗口一: ");
        Thread wd2 = new Thread(ticket, "窗口二: ");
        Thread wd3 = new Thread(ticket, "窗口三: ");
        Thread wd4 = new Thread(ticket, "窗口四: ");

        wd1.start();
        wd2.start();
        wd3.start();
        wd4.start();
    }
}

案例三: 实现两人共用一张银行卡, 一人存钱, 另一人取钱

public class BankCard {//创建银行卡类

    private double money;//余额

    public double getMoney() {
        return money;
    }

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

public class AddMoney implements Runnable{//创建存钱类, 实现Runnable接口

    private BankCard card;

    public AddMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            card.setMoney(card.getMoney() + 1000);
            System.out.println(Thread.currentThread().getName() + "存的第" + (i+1) + "笔钱,金额为1000元, 现卡上余额: " + card.getMoney() + "元");
        }

    }
}

public class SubMoney implements Runnable{//创建取钱类, 实现Runnable接口

    private BankCard card;

    public SubMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (card.getMoney() >= 1000){
                card.setMoney(card.getMoney() - 1000);
                System.out.println(Thread.currentThread().getName() + "取了第" + (i+1) + "笔钱,金额为1000元, 现卡上余额: " + card.getMoney() + "元");
            }else{
                System.out.println("余额不足...");
                i--;
            }
        }

    }
}

public class TestBankCard {

    public static void main(String[] args) {

        //1. 创建银行卡对象
        BankCard card = new BankCard();

        //2. 创建存钱对象
        AddMoney addMoney = new AddMoney(card);
        //3. 创建取钱对象
        SubMoney subMoney = new SubMoney(card);

        //4. 创建两个线程
        Thread boy = new Thread(addMoney, "男孩");
        Thread girl = new Thread(subMoney, "女孩");

        //5. 开启线程
        boy.start();
        girl.start();



    }
}

7. 线程的状态

(1) 基本

New(新创建): 线程对象被创建, 即为新创建状态. 只在堆中开辟内存, 与常规对象无异
Runnable(可运行): 调用start()后进入可运行状态, 等待被OS选中并分配时间片后开始运行, 时间片到期后又重新进入可运行状态,等待被OS选中
Terminated(终止状态): 主线程main()或独立线程run()结束, 进入终止状态, 并释放持有的时间片
- 正常终止: run()方法正常退出
- 意外终止: 因为一个没有捕获的异常终止了run()方法

(2) 阻塞

Blocked(阻塞): 当一个线程试图获取一个内部的对象锁,而该锁被其他线程持有, 则该线程进入阻塞状态. 当所有其他线程释放该锁, 并且线程调度器允许本线程持有它的时候, 该线程将变为非阻塞状态
Waiting(等待): 当线程等待另一个线程通知调度器一个条件时, 它自己进入等待状态, 调用以下方法时会出现这种情况
- Object.wait
- Thread.join
- java.util.concurrent库中的Lock或Condition
Timed Waiting(计时等待): 有几个方法有一个超时参数. 调用它们导致线程进入计时等待状态. 这一状态将一直保持到超时期满或者接收到适当的通知. 带有超时参数的方法有:
- Thread.sleep
- Object.wait
- Thread.join
- Lock.tryLock
- Condition.await的计时版

技术分享图片

8. 常见方法

休眠
- public static void sleep(long millis)
- 当前线程主动休眠 millis 毫秒
放弃
- public static void yield()
- 当前线程主动放弃时间片, 回到就绪状态, 竞争下一次时间片
加入
- public final void join()
- 允许其它线程加入到当前线程中
优先级
- 线程对象.setPriority
- 线程优先级为1-10. 默认为5, 优先级越高, 表示获取CPU机会越多
守护线程
- 线程对象.setDaemon(true); 设置为守护线程
- 线程有两类: 用户线程(前台线程), 守护线程(后台线程)
- 如果程序中所有前台线程都执行完毕了, 后台线程会自动结束
- 垃圾回收器线程属于守护线程

(1)sleep()方法休眠

public class SleepThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--------------" + i);
            try {
                SleepThread.sleep(2000);//睡眠两秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TestSleep {

    public static void main(String[] args) {

        SleepThread s1 = new SleepThread();
        SleepThread s2 = new SleepThread();

        s1.start();
        s2.start();
    }
}

(2)yield()方法让步

public class YieldThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-------------" + i);
            //放弃CPU
            YieldThread.yield();
        }
    }
}

public class TestYield {

    public static void main(String[] args) {

        YieldThread y1 = new YieldThread();
        YieldThread y2 = new YieldThread();

        y1.start();
        y2.start();
    }   
}

(3)join()方法加入

public class JoinThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "子线程------------" + i);
            try {
                JoinThread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TestJoin {

    public static void main(String[] args) {

        JoinThread j1 = new JoinThread();
        j1.start();
        try {
            j1.join();//加入到当前线程main, 并阻塞当前线程main, 直到加入的线程j1执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //主线程
        for (int i = 0; i < 30; i++) {
            System.out.println(Thread.currentThread().getName() + "主线程: " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

(4)优先级 Priority

public class PriorityThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "子线程:------ " + i);
        }
    }
}

public class TestPriority {

    public static void main(String[] args) {

        PriorityThread p1 = new PriorityThread();
        p1.setName("p1");
        PriorityThread p2 = new PriorityThread();
        p2.setName("p2");
        PriorityThread p3 = new PriorityThread();
        p3.setName("p3");
        p1.start();
        p2.start();
        p3.start();
        p1.setPriority(1);//优先级最低
        p2.setPriority(3);
        p3.setPriority(10);//优先级最高


        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "主线程:------ " + i);
        }
    }
}

(5)守护线程 Daemon

public class DaemonThread extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程: " + Thread.currentThread().getName() + "-----------" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TestDaemon {

    public static void main(String[] args) {

        //1. 创建线程(默认为前台线程)
        DaemonThread d1 = new DaemonThread();
        //2. 设置为守护线程(后台线程) 当主线程执行完毕后,守护线程(后台线程)会自动结束
        d1.setDaemon(true);
        d1.start();


        for (int i = 0; i < 10; i++) {
            System.out.println("主线程: " + Thread.currentThread().getName() + "-------" + i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


}

9. 线程安全

多线程安全问题
- 当多线程并发访问临界资源时, 如果破坏原子操作, 可能会造成数据不一致
- 临界资源: 共享资源(同一个对象), 一次仅允许一个线程使用, 才可保持其正确性
- 原子操作: 不可分割的多步操作, 被视作一个整体, 其顺序和步骤不可打乱或缺省

(1) 同步方式1

同步代码块:

synchronized(临界资源对象){ //对临界资源对象加锁

? //代码(原子操作)

}

注: 每个对象都有一个互斥锁标记, 用来分配给线程的. 只有拥有对象互斥锁标记的线程, 才能进入对该对象加锁的同步代码块.

线程退出同步代码块时, 会释放相应的互斥锁标记

import java.util.Arrays;

public class ThreadSafe {

    private static int index = 0;
    public static void main(String[] args) throws InterruptedException {

        //1. 创建数组
        String[] s = new String[5];

        //2. 创建两个操作
        Runnable runnableA = new Runnable() {
            @Override
            public void run() {
                //同步代码块
                synchronized (s){
                    s[index] = "hello";
                    index++;
                }
            }
        };
        Runnable runnableB = new Runnable() {
            @Override
            public void run() {
                //同步代码块
                synchronized (s){
                    s[index] = "world";
                    index++;
                }
            }
        };
        //3. 创建两个线程
        Thread thread1 = new Thread(runnableA, "A");
        Thread thread2 = new Thread(runnableB, "B");
        //4. 启动
        thread1.start();
        thread2.start();
        //5. 加入线程
        thread1.join();
        thread2.join();

        System.out.println(Arrays.toString(s));
    }
}

优化案例二(1): 使用同步代码块

实现四个窗口共同卖票100张, 不能出现四个窗口同时卖出一张票的情况

public class Ticket implements Runnable{

    private int ticket = 100;//票
    //创建锁
    //private Object obj = new Object();


    @Override
    public void run() {
        while (true){
            synchronized (this){//this---当前对象,这里放入obj和this都可以
                if (ticket <= 0){
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖的第" + (101-ticket) + "张票");
                ticket--;
            }

        }
    }
}

public class TestSafeTicket {

    public static void main(String[] args) {

        //1. 创建票对象
        Ticket ticket = new Ticket();

        //2. 创建四个线程对象
        Thread win1 = new Thread(ticket, "窗口一");
        Thread win2 = new Thread(ticket, "窗口二");
        Thread win3 = new Thread(ticket, "窗口三");
        Thread win4 = new Thread(ticket, "窗口四");

        //3. 启动
        win1.start();
        win2.start();
        win3.start();
        win4.start();

    }
}

优化案例三: 使用同步代码块

两人用同一张银行卡,一人存钱,另一人取钱, 不能出现存钱后卡上没钱或卡上没钱还能取出的情况

public class BankCard {

    private double money;//余额

    public double getMoney() {
        return money;
    }

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

public class TestBank {

    public static void main(String[] args) {

        //1. 创建银行卡对象
        BankCard bankCard = new BankCard();

        //2. 创建存钱取钱操作
        Runnable addMoney = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    synchronized (bankCard){
                        bankCard.setMoney(bankCard.getMoney() + 1000);
                        System.out.println(Thread.currentThread().getName() + "第" + i + "次存了1000元" + "现卡上余额: " + bankCard.getMoney());
                    }

                }

            }
        };
        Runnable subMoney = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    synchronized (bankCard){
                        if (bankCard.getMoney() >= 1000){

                            bankCard.setMoney(bankCard.getMoney()-1000);
                            System.out.println(Thread.currentThread().getName() + "第" + i + "次取了1000元" + "现卡上余额: " + bankCard.getMoney());
                        }else{
                            System.out.println("余额不足...");
                            i--;
                        }
                    }

                }
            }
        };

        //3. 创建两个线程
        Thread boy = new Thread(addMoney, "jack");
        Thread girl = new Thread(subMoney, "rose");

        boy.start();
        girl.start();

    }
}

(2) 同步方式2

同步方法:

synchronized 返回值类型方法名称(形参列表0) {//对当前对象(this)加锁

? //代码(原子操作)

}

注:

? 只有拥有对象互斥锁标记的线程, 才能进入对该对象加锁的同步方法中.

? 线程退出同步方法时, 会释放相应的互斥锁标记

优化案例二(2): 使用同步方法

public class Ticket1 implements Runnable{

    private int ticket1 = 100;


    @Override
    public void run() {
        while (true){
            if (!sell()){
                break;
            }
        }

    }

    public synchronized boolean sell(){//锁是this 代表当前对象ticket1, 如果是静态方法, 锁则是类Ticket1.class
        if (ticket1 > 0){
            System.out.println(Thread.currentThread().getName() + "卖的第" + (101-ticket1) + "张票");
            ticket1--;
        }
        return true;
    }
}

public class TestSafeTicket1 {

    public static void main(String[] args) {

        //1. 创建票对象
        Ticket1 ticket1 = new Ticket1();

        Thread w1 = new Thread(ticket1, "窗口1");
        Thread w2 = new Thread(ticket1, "窗口2");
        Thread w3 = new Thread(ticket1, "窗口3");
        Thread w4 = new Thread(ticket1, "窗口4");

        w1.start();
        w2.start();
        w3.start();
        w4.start();


    }
}

(3) 同步规则

注意:
- 只有在调用包含同步代码块的方法, 或同步方法时, 才需要对象的锁标记
- 如调用不包含同步代码块的方法, 或普通方法时,则不需要锁标记, 可直接调用
已知JDK中线程安全的类:
- StringBuffer
- Vector
- Hashtable
- 以上类中的公开方法, 均为synchronized修饰的同步方法

(4) 经典问题: 死锁

当第一个线程拥有A对象锁标记, 并等待B对象锁标记, 同时第二个线程拥有B对象锁标记, 并等待A对象锁标记时, 产生死锁
一个线程可以同时拥有多个对象的锁标记, 当线程阻塞时, 不会释放已经拥有的锁标记, 由此可能造成死锁

public class MyLock {

    //两个锁: 代表两根筷子,同时拿到这两根筷子才能吃饭
    public static Object lock1 = new Object();
    public static Object lock2 = new Object();

}

public class Boy extends Thread{

    @Override
    public void run() {
        synchronized (MyLock.lock1){
            System.out.println("男孩拿到了筷子A");
            synchronized (MyLock.lock2){
                System.out.println("男孩拿到了筷子B");
                System.out.println("男孩可以吃饭了");
            }
        }
    }
}

public class Girl extends Thread{

    @Override
    public void run() {
        synchronized (MyLock.lock2){
            System.out.println("女孩拿到了筷子B");
            synchronized (MyLock.lock1){
                System.out.println("女孩拿到了筷子A");
                System.out.println("女孩可以吃饭了");
            }
        }
    }
}

public class TestDeadLock {

    public static void main(String[] args) {

        //1. 创建两个线程对象男孩, 女孩
        Boy boy = new Boy();
        Girl girl = new Girl();

        //2. 女孩线程启动
        girl.start();
        //3. 休息0.5秒钟(如果他们两个同时启动就会造成死锁)
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //4. 最后启动男孩线程
        boy.start();


    }
}

(5) 线程通信

等待
- public final void wait()
- public final void wait(long timeout)
- 必须在对obj加锁的同步代码块中. 在一个线程中, 调用obj.wait() 时, 此线程会释放其拥有的所有锁标记. 同时此线程阻塞在obj的等待队列中. 释放锁, 进入等待队列
通知
- public final void notify()
- public final void notifyAll()
多存多取问题分析: 线程被重新唤醒后没有对标记flag进行判断
- 解决: 只需把if语句改成while, 每次线程被唤醒后重新判断一下标记
全部等待问题分析: 唤醒出现问题. notify 只能随机唤醒一个线程
- 解决: notify改为notifyAll

银行卡类

public class BankCard {

    //余额
    private double money;
    //标记
    private boolean flag = false;//true 表示有钱可以取不能存, false表示没钱可以存不能取

    //存钱
    public synchronized void deposit(double m){//this
        while (flag){//有钱
            try {
                this.wait();//进入等待队列 调用wait()方法的对象一定是锁,this代表锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money = money + m;
        System.out.println(Thread.currentThread().getName() + "存了" + m + "元, 当前余额为: " + money);
        //修改标记
        flag = true;
        //唤醒取钱线程
        this.notifyAll();
    }
    //取钱
    public synchronized void draw(double m){//this
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money = money - m;
        System.out.println(Thread.currentThread().getName() + "取了" + m + "元, 当前余额为: " + money);
        //修改标记
        flag = false;
        //唤醒存钱线程
        this.notifyAll();
    }
}

存钱

public class Deposit implements Runnable{

    private BankCard bankCard;
    public Deposit(BankCard bankCard){
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            bankCard.deposit(1000);
        }

    }
}

取钱

public class Draw implements Runnable{

    private BankCard bankCard;

    public Draw(BankCard bankCard){
        this.bankCard = bankCard;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            bankCard.draw(1000);
        }
    }
}

(6) 经典问题: 生产者, 消费者

若干个生产者在生产产品, 这些产品将提供给若干个消费者去消费, 为了使生产者和消费者能并发执行, 在两者之间设置一个能存储多个产品的缓冲区, 生产者将生产的产品放入缓冲区中, 消费者从缓冲区中取走产品进行消费, 显然生产者和消费者之间必须保持同步, 即不允许消费者到一个空的缓冲区中取产品, 也不允许生产者向一个满的缓冲区中放入产品

面包类

public class Bread {

    private int id;//产品id
    private String productName;//产家名称

    public Bread(int id, String productName) {
        this.id = id;
        this.productName = productName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }
}

存放面包的容器

public class BreadCon {

    //存放面包的数组
    private Bread[] cons = new Bread[6];
    //存放面包的位置
    private int index = 0;

    //存放面包
    public synchronized void input(Bread b){ // 锁this
        //判断容器有没有满
        while (index >= 6){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        cons[index] = b;
        System.out.println(Thread.currentThread().getName() + "生产了" + b.getId() + "号产品");
        index++;
        //唤醒
        this.notifyAll();

    }

    //取出面包
    public synchronized void output(){ // 锁this
        while (index <= 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        index--;
        Bread b = cons[index];
        System.out.println(Thread.currentThread().getName() + "消费了" + b.getProductName() + "生产的" + b.getId() + "号产品");
        cons[index] = null;
        //唤醒
        this.notifyAll();
    }
}

生产类

public class Product implements Runnable{
    private BreadCon con;

    public Product(BreadCon con) {
        this.con = con;
    }

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            con.input(new Bread(i, Thread.currentThread().getName()));
        }
    }
}

消费类

public class Consume implements Runnable{
    private BreadCon con;

    public Consume(BreadCon con) {
        this.con = con;
    }

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            con.output();
        }
    }
}

测试

public class Test {

    public static void main(String[] args) {
        //容器
        BreadCon con = new BreadCon();

        //生产和消费
        Product product = new Product(con);
        Consume consume = new Consume(con);

        //创建线程对象
        Thread p1 = new Thread(product, "1号厂家");
        Thread c1 = new Thread(consume, "1号消费者");
        Thread p2 = new Thread(product, "2号厂家");
        Thread c2 = new Thread(consume, "2号消费者");

        //启动线程
        p1.start();
        c1.start();
        p2.start();
        c2.start();
        
    }
}

10. 线程池

问题:
- 线程是宝贵的内存资源, 单个线程约占1MB空间, 过多分配易造成内存溢出
- 频繁的创建及销毁线程会增加虚拟机回收频率, 资源开销, 造成程序性能下降

(1) 线程池

线程容器, 可设定线程分配的数量上限
将预先创建的线程对象存入池中, 并重用线程池中的线程对象
避免频繁的创建和销毁

(2) 线程池原理

将任务提交给线程池, 由线程池分配线程, 运行任务, 并在当前任务结束后复用线程

(3) 创建线程池

常用的线程池接口和类(所在包java.util.concurrent):
- Executor: 线程池的顶级接口
- ExecutorService: 线程池接口, 可通过submit(Runnable task)提交任务代码
- Executors工厂类: 通过此类可以获得一个线程池
- 通过newFixedThreadPool(int nThreads) 获取固定数量的线程池. 参数: 指定线程池中线程的数量
- 通过newCachedThreadPool() 获得动态数量的线程池, 如不够则创建新的, 没有上限

public class Demo01 {

    public static void main(String[] args) {
        //1. 创建线程池
        //1.1 创建固定线程个数的线程池
        //ExecutorService es = Executors.newFixedThreadPool(4);
        //1.2 创建缓存线程池, 线程个数由任务个数决定
        ExecutorService es = Executors.newCachedThreadPool();
        //1.3 创建单线程池
        //Executors.newSingleThreadExecutor();
        //1.4 创建调度线程池
        //Executors.newScheduledThreadPool(3);
        //2. 创建任务
        Runnable runnable = new Runnable() {
            private int ticket = 100;
            @Override
            public void run() {
                while (true){
                    if (ticket <= 0){
                        break;
                    }
                    System.out.println(Thread.currentThread().getName() + "卖的第" + (101-ticket) + "张票");
                    ticket--;
                }
            }
        };
        //3. 提交任务
        for (int i = 0; i < 4; i++) {
            es.submit(runnable);
        }
        //4. 关闭线程池
        es.shutdown();//等待所有任务执行完毕后才会结束,关闭线程池
        //es.shutdownNow();//试图停止所有正在执行的活动任务, 暂停处理正在等待的任务,并返回等待执行的任务列表

    }
}

(4) Callable接口

public interface Callable{

? public V call() throws Exception;

}

JDK5加入, 与Runnable接口类似, 实现后代表一个线程任务
Callable具有泛型返回值, 可以声明异常

使用Callable实现1-100的和

public class Demo02 {

    public static void main(String[] args) throws Exception{

        //功能需求: 使用Callable实现1-100的和
        //1. 创建Callable对象
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName() + "开始计算: ");
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                }
                return sum;
            }
        };
        //2. 把Callable对象转成可执行的任务
        FutureTask<Integer> task = new FutureTask<>(callable);

        //3. 创建线程
        Thread thread = new Thread(task);

        //4. 启动线程
        thread.start();

        //5. 获取结果(等待call方法执行完毕,才会返回)
        Integer sum = task.get();
        System.out.println("结果是: " + sum);

    }
}

使用线程池计算1-100的和

public class Demo03 {

    public static void main(String[] args) throws Exception{
        
        //1. 创建线程池
        ExecutorService es = Executors.newFixedThreadPool(1);
        //2. 提交任务Future:表示将要执行完任务的结果
        Future<Integer> future = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName() + "开始计算: ");
                int sum = 0;
                for (int i = 1; i <= 100; i++) {
                    sum += i;
                    Thread.sleep(10);
                }
                return sum;
            }
        });
        //3. 获取任务结果,等待任务执行完毕才会返回
        System.out.println(future.get());

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

(5) Future接口

Future: 表示将要完成任务的结果
表示ExecutorService.submit()所返回的状态结果, 就是call()的返回值
方法: V get() 以阻塞形式等待Future中的异步处理结果(call()的返回值)
需求: 使用两个线程, 并发计算1~50, 50~100的和,再进行汇总

public class Demo04 {

    public static void main(String[] args) throws Exception{

        //1. 创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //2. 提交任务
        Future<Integer> future1 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 50; i++) {
                    sum += i;
                }
                System.out.println("1~50计算完毕");
                return sum;
            }
        });
        Future<Integer> future2 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 51; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("51~100计算完毕");
                return sum;
            }
        });

        //3. 获取结果
        int sum = future1.get() + future2.get();
        System.out.println("结果是: " + sum);

        //4. 关闭线程池
        es.shutdown();

    }
}

(6) 线程的同步和异步

同步
- 形容一次方法调用, 同步一旦开始, 调用者必须等待该方法返回, 才能继续
- 注: 单条执行路径
异步
- 形容一次方法调用, 异步一旦开始, 像是一次消息传递, 调用者告知之后立刻返回. 二者竞争时间片, 并发执行
- 注: 多条执行路径

11. Lock接口

JDK5加入, 与synchronized比较, 显示定义, 结构更灵活
提供更多实用性方法, 功能更强大, 性能更优越
常用方法:
- void lock() //获取锁, 如锁被占用, 则等待
- boolean tryLock() //尝试获取锁(成功返回true, 失败返回false, 不阻塞)
- void unlock() //释放锁

(1) 重入锁

ReentrantLock: Lock接口的实现类, 与synchronized一样具有互斥锁功能

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

public class MyList {

    private Lock lock = new ReentrantLock();
    private String[] str = {"A", "B", "", "", ""};
    private int count = 2;

    public void add(String value){
        lock.lock();
        try{
            str[count] = value;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
        } finally {
            lock.unlock();
        }
    }

    public String[] getStr(){
        return str;
    }
}

public class TestMyList {

    public static void main(String[] args) throws Exception{

        MyList list = new MyList();
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                list.add("hello");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                list.add("world");
            }
        };

        Thread t1 = new Thread(runnable1);
        Thread t2 = new Thread(runnable2);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(Arrays.toString(list.getStr()));
    }
}

使用重入锁实现4个窗口共同卖100张票

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

public class Ticket implements Runnable{

    private int ticket = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {

        while (true){
            lock.lock();
            try {

                if (ticket <= 0){
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖的第" + (101-ticket) + "张票");
                ticket--;

            } finally {
                lock.unlock();
            }
        }
    }
}

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

public class TestTicket {

    public static void main(String[] args) {

        //1. 创建票对象
        Ticket ticket = new Ticket();

        //2. 创建线程池对象
        ExecutorService es = Executors.newFixedThreadPool(4);

        //3. 提交任务
        for (int i = 0; i < 4; i++) {
            es.submit(ticket);
        }
		//4. 关闭线程池
        es.shutdown();



    }
}

(2) 读写锁

ReentrantReadWriteLock
- 一种支持一写多读的同步锁, 读写分离, 可分别分配读锁, 写锁
- 支持多次分配读锁, 使多个读操作可以并发执行
互斥规则
- 写-写: 互斥
- 读-写: 互斥, 读阻塞写, 写阻塞读
- 读-读: 不互斥, 不阻塞
- 在读操作远远高于写操作的环境中, 可在保障线程安全的情况下, 提高运行效率

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class ReadWriteLock {

    //创建读写锁
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    //获取读锁
    private ReadLock readLock = rwl.readLock();
    //获取写锁
    private WriteLock writeLock = rwl.writeLock();

    private String value;

    //读取
    public String getValue(){
        //使用读锁上锁
        readLock.lock();

        try {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("读取: " + this.value);
            return this.value;
        } finally {
            readLock.unlock();
        }
    }

    //写入
    public void setValue(String value){
        //使用写锁上锁
        writeLock.lock();

        try {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.value = value;
            System.out.println("写入: " + value);
        } finally {
            writeLock.unlock();
        }
    }

}

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestReadWriteLock {

    public static void main(String[] args) {
        //1. 创建读写锁对象
        ReadWriteLock rwl = new ReadWriteLock();
        //2. 创建线程池
        ExecutorService es = Executors.newFixedThreadPool(20);
        //3. 创建写任务
        Runnable write = new Runnable() {
            @Override
            public void run() {
                rwl.setValue("张三: " + new Random().nextInt(100));
            }
        };
        //4. 创建读任务
        Runnable read = new Runnable() {
            @Override
            public void run() {
                rwl.getValue();
            }
        };
        Long start = System.currentTimeMillis();//获取系统此刻时间(开始)
        //5. 分配2个线程来 写任务
        for (int i = 0; i < 2; i++) {
            es.submit(write);
        }
        //6. 分配18个线程来 读任务
        for (int i = 0; i < 18; i++) {
            es.submit(read);
        }
        //7. 关闭
        es.shutdown();
        while (!es.isTerminated()) {//空转

        }
        Long end = System.currentTimeMillis();//获取系统此刻时间(结束)
        System.out.println("用时: " + (end - start));//3007  如果使用用互斥锁时间为: 20048
    }
}

12. 线程安全的集合

Collection体系集合中, 除Vector以外的线程安全集合
Map安全集合体系

(1)CopyOnWriteArrayList

线程安全的ArrayList, 加强版的读写分离
写有锁, 读无锁, 读写之间不阻塞, 优于读写锁
写入时, 先copy一个容器副本, 再添加新元素, 最后替换引用
使用方式和ArrayList无异

public class Demo02 {

    public static void main(String[] args) {

        //1. 创建集合
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        //2. 使用多线程操作
        ExecutorService es = Executors.newFixedThreadPool(5);
        //3. 提交任务
        for (int i = 0; i < 5; i++) {
            es.submit(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        list.add(Thread.currentThread().getName() + "---" + new Random().nextInt(1000));
                    }
                }
            });
        }
        //4. 关闭线程池
        es.shutdown();
        while (!es.isTerminated()){}
        //5. 打印结果
        System.out.println("元素个数: " + list.size());
        for (String s : list) {
            System.out.println(s);
        }

    }
}

(2)CopyOnWriteArraySet

线程安全的Set, 底层使用CopyOnWriteArrayList实现
唯一不同在于, 使用addIfAbsent() 添加元素, 会遍历数组
如存在元素, 则不添加(扔掉副本),重复依据 equals()方法

(3)Queue接口(队列)

Collection的子接口, 表示队列FIFO(First In First Out)先进先出
常用方法:
- 抛出异常:
  - boolean add(E e) //顺序添加一个元素(到达上限后, 再附加则会抛出异常)
  - E remove() //获得第一个元素并移除(如果队列没有元素时, 则抛异常)
  - E element() //获得第一个元素但不移除(如果队列没有元素时, 则抛异常)
- 返回特殊值: 推荐使用
  - boolean offrt (E e) //顺序添加一个元素(到达上限后, 再添加则会返回false)
  - E poll() //获得第一个元素并移除 (如果队列没有元素时,则返回null)
  - E peek() //获得第一个元素但不移除(如果队列没有元素时, 则返回null)

public class Demo04 {

    public static void main(String[] args) {

        //1. 创建队列
        Queue<String> queue = new LinkedList<>();// LinkedList是线程不安全的集合,不能使用多线程
        //2. 入队
        queue.offer("香蕉");
        queue.offer("苹果");
        queue.offer("橘子");
        queue.offer("橙子");
        System.out.println("入队完毕, 元素个数: " + queue.size());
        System.out.println(queue.peek());//获取队列第一个元素但不移除
        System.out.println("----------------------");
        //3. 出队
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            System.out.println(queue.poll());//获得第一个元素并移除
        }
        System.out.println("出队完毕, 元素个数: " + queue.size());
    }
}

(4)ConcurrentLinkedQueue

线程安全, 可高效读写的队列, 高并发下性能最好的队列
无锁, CAS比较交换算法, 修改的方法包含三个核心参数(V,E,N)
V: 要更新的变量, E: 预期值, N: 新值
只有当V=E时, V=N; 否则表示已被更新过, 则取消当前操作

public class Demo05 {

    public static void main(String[] args) throws Exception{
        //1. 创建线程安全集合
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        //2. 入队操作
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    queue.offer(i);
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 5; i < 10; i++) {
                    queue.offer(i);
                }
            }
        });
        //3. 启动线程
        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
        //4. 出队操作
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            System.out.println(queue.poll());
        }
        System.out.println("出队成功, 元素个数: " + queue.size());

    }
}

(5)BlockingQueue接口

Queue的子接口, 阻塞的队列, 增加了两个线程状态为无限期等待的方法
方法:
- void put(E e) //将指定元素插入此队列中, 如果没有可用空间, 则等待
- E take() //获取并移除此队列头部元素, 如果没有可用元素, 则等待
可用于解决生产者, 消费者问题

(6)ArrayBlockingQueue

数据结构实现, 有界队列. (手工固定上限)

public class Demo06 {

    public static void main(String[] args) throws Exception{

        //1. 创建一个有界队列, 添加数据
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
        //2. 添加元素
        queue.put("aaa");
        queue.put("bbb");
        queue.put("ccc");
        queue.put("ddd");
        queue.put("eee");
        System.out.println("已经添加了5个元素");
        //queue.put("fff");//无法添加,因为队列此时满了
        //System.out.println("已经添加了6个元素");
        //3. 删除元素
        queue.take();//删除第一个
        System.out.println(queue.toString());


    }
}

使用阻塞队列实现生产者和消费者

public class Demo07 {

    public static void main(String[] args) {

        //1. 创建队列
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(6);
        //2. 创建两个线程
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 30; i++) {
                    try {
                        queue.put(i);
                        System.out.println(Thread.currentThread().getName() + "生产了第" + i + "个面包");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "张三");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 30; i++) {
                    try {
                        queue.take();
                        System.out.println(Thread.currentThread().getName() + "消费了第" + i + "个面包");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }


                }
            }
        }, "李四");
        //3. 启动线程
        t1.start();
        t2.start();
    }
}

(7)LinkedBlockingQueue

链表结构实现, 有界队列. (默认上限Integer.MAX_VALUE)

(8)ConcurrentHashMap

初始容量默认为16段(Segment), 使用分段锁设计(JDK1.7之前), (JDK1.8之后使用无锁, CAS比较交换算法)
不对整个Map加锁, 而是为每个Segment加锁
当多个对象存入同一个Segment时, 才会互斥
最理想状态为16个对象分被存入16个Segment, 并行数量16
使用方式与HashMap无异

public class Demo08 {

    public static void main(String[] args) {

        //1. 创建集合
        ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>();
        //2. 使用多线程添加数据
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        hashMap.put(Thread.currentThread().getName()+ "---" + j, j + "");
                        System.out.println(hashMap);
                    }
                }
            }).start();
        }
    }
}

21_多线程

原文：https://www.cnblogs.com/MRASdoubleZ/p/14503013.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)

21_多线程

1. 什么是进程

2. 什么是线程

3. 进程和线程的区别

4. 线程的组成

5. 线程的特点

6. 创建线程

方式一: 继承Thread类, 重写run方法

案例一: 实现四个窗口同时各卖票100张

方式二: 实现Runnable接口

案例二: 实现四个窗口共同卖票100张

案例三: 实现两人共用一张银行卡, 一人存钱, 另一人取钱

7. 线程的状态

(1) 基本

(2) 阻塞

8. 常见方法

(1)sleep()方法 休眠

(2)yield()方法 让步

(3)join()方法 加入

(4)优先级 Priority

(5)守护线程 Daemon

9. 线程安全

(1) 同步方式1

优化案例二(1): 使用同步代码块

优化案例三: 使用同步代码块

(2) 同步方式2

优化案例二(2): 使用同步方法

(3) 同步规则

(4) 经典问题: 死锁

(5) 线程通信

(6) 经典问题: 生产者, 消费者

10. 线程池

(1) 线程池

(2) 线程池原理

(3) 创建线程池

(4) Callable接口

(5) Future接口

(6) 线程的同步和异步

11. Lock接口

(1) 重入锁

(2) 读写锁

12. 线程安全的集合

(1)CopyOnWriteArrayList

(2)CopyOnWriteArraySet

(3)Queue接口(队列)

(4)ConcurrentLinkedQueue

(5)BlockingQueue接口

(6)ArrayBlockingQueue

(7)LinkedBlockingQueue

(8)ConcurrentHashMap

(1)sleep()方法休眠

(2)yield()方法让步

(3)join()方法加入