其他分享
首页 > 其他分享> > day17-2021-12-22

day17-2021-12-22

作者:互联网

湖南

进程 线程 多线程

1.进程

1.1进程的概念

进程就是正在运行的程序,它会占用对应的内存区域,由CPU进行执行与计算。

1.2进程的特点

2.线程

2.1线程的概念

线程是操作系统OS能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位.
一个进程可以开启多个线程,其中有一个主线程来调用本进程中的其他线程。
我们看到的进程的切换,切换的也是不同进程的主线程
多线程可以让同一个进程同时并发处理多个任务,相当于扩展了进程的功能。

2.2进程与线程的关系

一个操作系统中可以有多个进程,一个进程中可以包含一个线程(单线程程序),也可以包含多个线程(多线程程序)

每个线程在共享同一个进程中的内存的同时,又有自己独立的内存空间.
所以想使用线程技术,得先有进程,进程的创建是OS操作系统来创建的,一般都是C或者C++完成

3.多线程的特性

3.1随机性

我们宏观上觉得多个进程是同时运行的,但实际的微观层面上,一个CPU【单核】只能执行一个进程中的一个线程。
那为什么看起来像是多个进程同时执行呢?
是因为CPU以纳秒级别甚至是更快的速度高效切换着,超过了人的反应速度,这使得各个进程从看起来是同时进行的,也就是说,宏观层面上,所有的进程看似并行【同时运行】,但是微观层面上是串行的【同一时刻,一个CPU只能处理一件事】

串行与并行
串行是指同一时刻一个CPU只能处理一件事,类似于单车道
并行是指同一时刻多个CPU可以处理多件事,类似于多车道

3.2CPU分时调度

时间片,即CPU分配给各个线程的一个时间段,称作它的时间片,即该线程被允许运行的时间,如果在时间片用完时线程还在执行,那CPU将被剥夺并分配给另一个线程,将当前线程挂起,如果线程在时间片用完之前阻塞或结束,则CPU当即进行切换,从而避免CPU资源浪费,当再次切换到之前挂起的线程,恢复现场,继续执行。
注意:我们无法控制OS选择执行哪些线程,OS底层有自己规则,如:

  1. FCFS(First Come First Service 先来先服务算法)
  2. SJS(Short Job Service短服务算法)

3.3线程的状态

由于线程状态比较复杂,我们由易到难,先学习线程的三种基础状态及其转换,简称”三态模型” :

就绪 → 执行:为就绪线程分配CPU即可变为执行状态"
执行 → 就绪:正在执行的线程由于时间片用完被剥夺CPU暂停执行,就变为就绪状态
执行 → 阻塞:由于发生某事件,使正在执行的线程受阻,无法执行,则由执行变为阻塞
(例如线程正在访问临界资源,而资源正在被其他线程访问)
反之,如果获得了之前需要的资源,则由阻塞变为就绪状态,等待分配CPU再次执行

我们可以再添加两种状态:

3.4线程状态与代码对照

线程生命周期,主要有五种状态:

  1. 新建状态(New) : 当线程对象创建后就进入了新建状态.如:Thread t = new MyThread();
  2. 就绪状态(Runnable):当调用线程对象的start()方法,线程即为进入就绪状态.
    处于就绪(可运行)状态的线程,只是说明线程已经做好准备,随时等待CPU调度执行,并不是执行了t.start()此线程立即就会执行
  3. 运行状态(Running):当CPU调度了处于就绪状态的线程时,此线程才是真正的执行,即进入到运行状态
    就绪状态是进入运行状态的唯一入口,也就是线程想要进入运行状态状态执行,先得处于就绪状态
  4. 阻塞状态(Blocked):处于运状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入就绪状态才有机会被CPU选中再次执行.
    根据阻塞状态产生的原因不同,阻塞状态又可以细分成三种:
    等待阻塞:运行状态中的线程执行wait()方法,本线程进入到等待阻塞状态
    同步阻塞:线程在获取synchronized同步锁失败(因为锁被其他线程占用),它会进入同步阻塞状态
    其他阻塞:调用线程的sleep()或者join()或发出了I/O请求时,线程会进入到阻塞状态.当sleep()状态超时.join()等待线程终止或者超时或者I/O处理完毕时线程重新转入就绪状态
  5. 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期

4.多线程代码创建方式1:继承Thread

4.1概述

Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例
启动线程的唯一方法就是通过Thread类的start()实例方法
start()方法是一native方法,它将通知底层操作系统,.最终由操作系统启动一个新线程,操作系统将执行run()
这种方式实现的多线程很简单,通过自己的类直接extends Thread,并重写run()方法,就可以自动启动新线程并执行自己定义的run()方法
模拟开启多个线程,每个线程调用run()方法.

4.2常用方法

构造方法
Thread() 分配新的Thread对象
Thread(String name) 分配新的Thread对象
Thread(Runnable target) 分配新的Thread对象
Thread(Runnable target,String name) 分配新的Thread对象
普通方法
static Thread currentThread( )
返回对当前正在执行的线程对象的引用
long getId()
返回该线程的标识
String getName()
返回该线程的名称
void run()
如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法
static void sleep(long millions)
在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
void start()
使该线程开始执行:Java虚拟机调用该线程的run()

4.3测试多线程的创建方式1

创建包:cn.tedu.thread
创建类:TestThread1.java

package cn.tedu.thread;
/本类用于多线程编程实现方案一:继承Thread类来完成/
public class TestThread1 {
public static void main(String[] args) {
//4.创建线程对象进行测试
/4.new对应的是线程的新建状态
* 5.要想模拟多线程,至少得启动2个线程,如果只启动1个,是单线程程序
/
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
MyThread t4 = new MyThread();
/6.这个run()如果直接这样调用,是没有多线程抢占执行的效果的
* 只是把这两句话看作普通方法的调用,谁先写,就先执行谁
/
//t1.run();
//t2.run();
/7.start()对应的状态就是就绪状态,会把刚刚新建好的线程加入到就绪队列之中
* 至于什么时候执行,就是多线程执行的效果,需要等待OS选中分配CPU
* 8.执行的时候start()底层会自动调用我们重写的run()种的业务
* 9.线程的执行具有随机性,也就是说t1-t4具体怎么执行
* 取决于CPU的调度时间片的分配,我们是决定不了的
/
t1.start();//以多线程的方式启动线程1,将当前线程变为就绪状态
t2.start();//以多线程的方式启动线程2,将当前线程变为就绪状态
t3.start();//以多线程的方式启动线程3,将当前线程变为就绪状态
t4.start();//以多线程的方式启动线程4,将当前线程变为就绪状态
}
}

//1.自定义一个多线程类,然后让这个类继承Thread
class MyThread extends Thread{
/1.多线程编程实现的方案1:通过继承Thread类并重写run()来完成的 /
//2.重写run(),run()里是我们自己的业务
@Override
public void run() {
/
2.super.run()表示的是调用父类的业务,我们现在要用自己的业务,所以注释掉
/
//super.run();
//3.完成业务:打印10次当前正在执行的线程的名称
for (int i = 0; i < 10; i++) {
/3.getName()表示可以获取当前正在执行的线程名称
* 由于本类继承了Thread类,所以可以直接使用这个方法
/
System.out.println(i+"="+getName());
}
}
}

5.多线程代码创建方式2:实现Runnable接口

5.1概述

如果自己的类已经extends另一个类,就无法多继承,此时,可以实现一个Runnable接口

5.2常用方法

void run()使用实现接口Runnable的对象创建线程时,启动该线程将导致在独立执行的线程中调用对象的run()方法

5.3练习2:测试多线程的创建方式2

创建包:cn.tedu.thread
创建类:Thread2.java

package cn.tedu.thread;
/*本类用于多线程编程实现方案二:实现Runnable接口来完成*/
public class TestThread2 {
    public static void main(String[] args) {
        //5.创建自定义类的对象--目标业务类对象
        MyRunnable target = new MyRunnable();
        //6.如何启动线程?自己没有,需要与Thread建立关系
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程类
class MyRunnable implements Runnable{
    //2.添加父接口中的抽象方法run(),里面是自己的业务
    @Override
    public void run() {
        //3.写业务,打印10次当前正在执行的线程名称
        for (int i = 0; i < 10; i++) {
            /*问题:自定义类与父接口Runnable中都没有获取名字的方法
            * 所以还需要从Thread中找:
            * currentThread():静态方法,获取当前正在执行的线程对象
            * getName():获取当前线程的名称*/
            System.out.println(i+"="+Thread.currentThread().getName());
        }
    }
}

5.4两种实现方式的比较

6.售票案例

需求:设计4个售票窗口,总计售票100张。用多线程的程序设计并写出代码

6.1方案1:继承Thread

创建包:cn.tedu.tickets
创建类:TestThread.java

package cn.tedu.tickets;
/*需求:设计多线程编程模型,4个窗口共计售票100张
* 本方案使用多线程编程方案1,继承Thread类的方式来完成*/
public class TestThread {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程售票类,继承Thread
class TicketThread extends Thread{
    //3.定义变量,保存要售卖的票数
    /*问题:4个线程对象共计售票400张,原因是创建了4次对象,各自操作各自的成员变量
    * 解决:让所有对象共享同一个数据,票数需要设置为静态*/
    static int tickets = 100;
    //2.重写父类的run(),里面是我们的业务
    @Override
    public void run() {
        //4.1循环卖票
        while(true){
            try {
                //7.让每个线程经历休眠,增加线程状态切换的频率与出错的概率
                //问题1:产生了重卖的现象:同一张票卖了多个人
                //问题2:产生了超卖的现象:超出了规定的票数100,出现了0 -1 -2这样的票
                Thread.sleep(10);//让当前线程休眠10ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //4.2打印当前正在卖票的线程名称,并且票数-1
            System.out.println(getName()+"="+tickets--);
            //4.3做判断,如果没有票了,就退出死循环
            if(tickets <= 0) break;//注意,死循环一定要设置出口
        }
    }
}

6.2方案2:实现Runnable

创建包:cn.tedu.tickets
创建类:TestRunnable.java

package cn.tedu.tickets;
/*需求:设计多线程编程模型,4个窗口共计售票100张
* 本方案使用多线程编程方案1,继承Thread类的方式来完成*/
public class TestThread {
    public static void main(String[] args) {
        //5.创建多个线程对象
        TicketThread t1 = new TicketThread();
        TicketThread t2 = new TicketThread();
        TicketThread t3 = new TicketThread();
        TicketThread t4 = new TicketThread();
        //6.以多线程的方式启动
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程售票类,继承Thread
class TicketThread extends Thread{
    //3.定义变量,保存要售卖的票数
    /*问题:4个线程对象共计售票400张,原因是创建了4次对象,各自操作各自的成员变量
    * 解决:让所有对象共享同一个数据,票数需要设置为静态*/
    static int tickets = 100;
    //2.重写父类的run(),里面是我们的业务
    @Override
    public void run() {
        //4.1循环卖票
        while(true){
            try {
                //7.让每个线程经历休眠,增加线程状态切换的频率与出错的概率
                //问题1:产生了重卖的现象:同一张票卖了多个人
                //问题2:产生了超卖的现象:超出了规定的票数100,出现了0 -1 -2这样的票
                Thread.sleep(10);//让当前线程休眠10ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //4.2打印当前正在卖票的线程名称,并且票数-1
            System.out.println(getName()+"="+tickets--);
            //4.3做判断,如果没有票了,就退出死循环
            if(tickets <= 0) break;//注意,死循环一定要设置出口
        }
    }
}

6.3问题

  1. 每次创建线程对象,都会生成一个tickets变量值是100,创建4次对象就生成了400张票了。不符合需求,怎么解决呢?能不能把tickets变量在每个对象间共享,就保证多少个对象都是卖这100张票。
    解决方案: 用静态修饰
  2. 产生超卖,0张、-1张、-2张
  3. 产生重卖,同一张票卖给多人。
  4. 多线程安全问题是如何出现的?常见情况是由于线程的随机性+访问延迟。
  5. 以后如何判断程序有没有线程安全问题?
    在多线程程序中 + 有共享数据 + 多条语句操作共享数据

同步锁 线程安全问题解决方案

1.同步锁

1.1前言

经过前面多线程编程的学习,我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.
上节笔记点这里-进程与线程笔记

我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件:

在多线程程序中 + 有共享数据 + 多条语句操作共享数据
多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
那我们可以把有可能出现问题的代码都包裹起来,一次只让一个线程来执行

1.2同步与异步

那怎么"把有可能出现问题的代码都包裹起来"呢?我们可以使用synchronized关键字来实现同步效果
也就是说,当多个对象操作共享数据时,可以使用同步锁解决线程安全问题,被锁住的代码就是同步的

接下来介绍下同步与异步的概念:
同步:体现了排队的效果,同一时刻只能有一个线程独占资源,其他没有权利的线程排队。
坏处就是效率会降低,不过保证了安全。
异步:体现了多线程抢占资源的效果,线程间互相不等待,互相抢占资源。
坏处就是有安全隐患,效率要高一些。

1.3synchronized同步关键字

1.31写法

synchronized (锁对象){undefined
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}

1.32前提

同步效果的使用有两个前提:

1.3.3特点
  1. synchronized同步关键字可以用来修饰代码块,称为同步代码块,使用的锁对象类型任意,但注意:必须唯一!

  2. synchronized同步关键字可以用来修饰方法,称为同步方法

  3. 同步的缺点是会降低程序的执行效率,但我们为了保证线程的安全,有些性能是必须要牺牲的

  4. 但是为了性能,加锁的范围需要控制好,比如我们不需要给整个商场加锁,试衣间加锁就可以了

    为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢?
    因为同步代码块可以保证同一个时刻只有一个线程进入
    但同步方法不可以保证同一时刻只能有一个线程调用,所以使用本类代指对象this来确保同步

1.4.1练习-改造售票案例

创建包:cn.tedu.tickets
创建类:TestRunnableV2.java

package cn.tedu.tickets;

/*本类用于改造多线程售票案例,解决数据安全问题*/
public class TestRunnableV2 {
    public static void main(String[] args) {
        //5.创建目标业务类对象
        TicketR2 target = new TicketR2();
        //6.创建线程对象
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        //7.以多线程的方式运行
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

/*1.多线程中出现数据安全问题的原因:多线程程序+共享数据+多条语句操作共享数据*/
/*2.同步锁:相当于给容易出现问题的代码加了一把锁,包裹了所有可能会出现数据安全问题的代码
 * 加锁之后,就有了同步(排队)的效果,但是加锁的话,需要考虑:
 * 锁的范围:不能太大,太大,干啥都得排队,也不能太小,太小,锁不住,还是会有安全隐患*/
//1.创建自定义多线程类
class TicketR2 implements Runnable {
    //3.定义成员变量,保存票数
    int tickets = 100;
    //创建锁对象
    Object o = new Object();

    //2.实现接口中未实现的方法,run()中放着的是我们的业务
    @Override
    public void run() {
        //4.通过循环结构完成业务
        while (true) {
            /*3.同步代码块:synchronized(锁对象){会出现安全隐患的所有代码}
             * 同步代码块在同一时刻,同一资源只会被一个线程独享*/
            /*这种写法不对,相当于每个线程进来的时候都会new一个锁对象,线程间使用的并不是同一把锁*/
            //synchronized (new Object()){
            //修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
            synchronized (o) {//同步代码块解决的是重卖的问题
                //如果票数>0就卖票
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //4.1打印当前正在售票的线程名以及票数-1
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                //4.2退出死循环--没票的时候就结束
                if (tickets <= 0) break;
            }
        }
    }
}
1.4.2练习-改造售票案例

创建包:cn.tedu.tickets
创建类:TestThreadV2.java

package cn.tedu.tickets;

/*本类用于改造多线程售票案例,解决数据安全问题*/
public class TestThreadV2 {
    public static void main(String[] args) {
        //5.创建多个线程对象并以多线程的方式运行
        TickectT2 t1 = new TickectT2();
        TickectT2 t2 = new TickectT2();
        TickectT2 t3 = new TickectT2();
        TickectT2 t4 = new TickectT2();
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程类
class TickectT2 extends Thread {
    //3.新增成员变量用来保存票数
    static int tickets = 100;
    //static Object o = new Object();

    //2.添加重写的run()来完成业务
    @Override
    public void run() {
        //3.创建循环结构用来卖票
        while (true) {
            //Ctrl+Alt+L调整代码缩进
            //7.添加同步代码块,解决数据安全问题
            //synchronized (new Object()) {
            /*static的Object的对象o这种写法也可以*/
            //synchronized (o) {
            /*我们每通过class关键字创建一个类,就会在工作空间中生成一个唯一对应的类名.class字节码文件
            * 这个类名.class对应的对象我们称之为这个类的字节码对象
            * 字节码对象极其重要,是反射技术的基石,字节码对象中包含了当前类所有的关键信息
            * 所以,用这样一个唯一且明确的对象作为同步代码块的锁对象,再合适不过了*/
            synchronized (TickectT2.class) {/*比较标准的写法*/
                if(tickets > 0){
                    //6.添加线程休眠,暴露问题
                    try {
                        Thread.sleep(10);//让线程休眠,增加线程状态切换的频率
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //4.1打印当前正在售票的线程名与票数-1
                    System.out.println(getName() + "=" + tickets--);
                }
                //4.2给程序设置一个出口,没有票的时候就停止卖票
                if (tickets <= 0) break;
            }
        }
    }
}

注意:如果是继承的方式的话,锁对象最好用"类名.class",否则创建自定义线程类多个对象时,无法保证锁的唯一

1.5之前遇到过的同步例子

StringBuffer JDK1.0
加了synchronized ,性能相对较低(要排队,同步),安全性高
StringBuilder JDK1.5
去掉了synchronized,性能更高(不排队,异步),存在安全隐患

快速查找某个类的快捷键:Ctrl+Shift+T

2.线程创建的其他方式

2.1ExecutorService/Executors

ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理

Executors 辅助创建线程池的工具类

2.2练习:线程的其他创建方式

创建包:cn.tedu.tickets
创建类:TestThreadPool.java

package cn.tedu.tickets;

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

/*本类用于测试线程池*/
public class TestThreadPool {
    public static void main(String[] args) {
        //5.创建接口实现类TicketR3类的对象作为目标业务对象
        TicketR3 target = new TicketR3();
        /*Executors是用来辅助创建线程池的工具类对象
        * 常用方法是newFixedThreadPool(int)这个方法可以创建指定数目的线程池对象
        * 创建出来的线程池对象是ExecutorService:用来存储线程的池子,负责:新建/启动/关闭线程*/
        //6.使用Executors工具创建一个最多有5个线程的线程池对象ExecutorService池对象
        ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            /*execute()让线程池中的线程来执行业务,每次调用都会将一个线程加入到就绪队列*/
            pool.execute(target);/*本方法的参数就是你要执行的业务,也就是目标业务类对象*/
        }
    }
}
//同步锁问题解决方案笔记:1.4.1从26行复制到58行,TicketR2改成TicketR3
//1.创建自定义多线程类
class TicketR3 implements Runnable {
    //3.定义成员变量,保存票数
    int tickets = 100;
    //创建锁对象
    Object o = new Object();

    //2.实现接口中未实现的方法,run()中放着的是我们的业务
    @Override
    public void run() {
        //4.通过循环结构完成业务
        while (true) {
            /*3.同步代码块:synchronized(锁对象){会出现安全隐患的所有代码}
             * 同步代码块在同一时刻,同一资源只会被一个线程独享*/
            /*这种写法不对,相当于每个线程进来的时候都会new一个锁对象,线程间使用的并不是同一把锁*/
            //synchronized (new Object()){
            //修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
            synchronized (o) {//同步代码块解决的是重卖的问题
                //如果票数>0就卖票
                if (tickets > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //4.1打印当前正在售票的线程名以及票数-1
                    System.out.println(Thread.currentThread().getName() + "=" + tickets--);
                }
                //4.2退出死循环--没票的时候就结束
                if (tickets <= 0) break;
            }
        }
    }
}

3.拓展:线程锁

3.1悲观锁和乐观锁

悲观锁:像它的名字一样,对于并发间操作产生的线程安全问题持悲观状态.
悲观锁认为竞争总是会发生,因此每次对某资源进行操作时,都会持有一个独占的锁,就像synchronized,不管三七二十一,直接上了锁就操作资源了。

乐观锁:还是像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态.
乐观锁认为竞争不总是会发生,因此它不需要持有锁,将”比较-替换”这两个动作作为一个原子操作尝试去修改内存中的变量,如果失败则表示发生冲突,那么就应该有相应的重试逻辑。

3.2两种常见的锁

synchronized 互斥锁(悲观锁,有罪假设)
采用synchronized修饰符实现的同步机制叫做互斥锁机制,它所获得的锁叫做互斥锁。
每个对象都有一个monitor(锁标记),当线程拥有这个锁标记时才能访问这个资源,没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁,这个锁是为了分配给线程的,防止打断原子操作。每个对象的锁只能分配给一个线程,因此叫做互斥锁。

ReentrantLock 排他锁(悲观锁,有罪假设)
ReentrantLock是排他锁,排他锁在同一时刻仅有一个线程可以进行访问,实际上独占锁是一种相对比较保守的锁策略,在这种情况下任何“读/读”、“读/写”、“写/写”操作都不能同时发生,这在一定程度上降低了吞吐量。然而读操作之间不存在数据竞争问题,如果”读/读”操作能够以共享锁的方式进行,那会进一步提升性能。

ReentrantReadWriteLock 读写锁(乐观锁,无罪假设)
因此引入了ReentrantReadWriteLock,顾名思义,ReentrantReadWriteLock是Reentrant(可重入)Read(读)Write(写)Lock(锁),我们下面称它为读写锁。
读写锁内部又分为读锁和写锁,读锁可以在没有写锁的时候被多个线程同时持有,写锁是独占的。
读锁和写锁分离从而提升程序性能,读写锁主要应用于读多写少的场景。

3.3尝试用读写锁改造售票案例

package cn.tedu.thread;

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

/**
 * 本类用于改造售票案例,使用可重入读写锁
 * ReentrantReadWriteLock
 * */
public class TestSaleTicketsV3 {
	public static void main(String[] args) {
		SaleTicketsV3 target = new SaleTicketsV3();
		Thread t1 = new Thread(target);
		Thread t2 = new Thread(target);
		Thread t3 = new Thread(target);
		Thread t4 = new Thread(target);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
class SaleTicketsV3 implements Runnable{
	static int tickets = 100;
	//1.定义可重入读写锁对象,静态保证全局唯一
	static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
	@Override
	public void run() {
		while(true) {
			//2.在操作共享资源前上锁
			lock.writeLock().lock();
			try {
				if(tickets > 0) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "=" + tickets--);
				}
				if(tickets <= 0) break;
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				//3.finally{}中释放锁,注意一定要手动释放,防止死锁,否则就独占报错了
				lock.writeLock().unlock();
			}
		}
	}
} 

3.4两种方式的区别

需要注意的是,用sychronized修饰的方法或者语句块在代码执行完之后锁会自动释放,而是用Lock需要我们手动释放锁,所以为了保证锁最终被释放(发生异常情况),要把互斥区放在try内,释放锁放在finally内!
与互斥锁相比,读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(writer 线程)可以修改共享数据,但在许多情况下,任何数量的线程可以同时读取共享数据(reader 线程)从理论上讲,与互斥锁定相比,使用读-写锁允许的并发性增强将带来更大的性能提高。

标签:tickets,12,Thread,start,day17,线程,2021,new,多线程
来源: https://www.cnblogs.com/elliottmoo/p/15725202.html