Java基础加强重温_08：线程不安全、线程同步、线程状态、线程状态切换、线程池（Executors类、newFixedThreadPool）、死锁、Lambda表达式、Stream

最新推荐文章于 2022-02-15 09:04:41 发布

Jinniu00

最新推荐文章于 2022-02-15 09:04:41 发布

阅读量497

点赞数

分类专栏： Java基础系列文章标签： java 大数据编程语言

本文链接：https://blog.csdn.net/qq_45942076/article/details/105290871

版权

摘要

Java基础加强重温_08：
线程安全（线程安全概念、线程不安全案例）、
线程同步（同步代码块、同步方法、Lock锁，锁对象）、
线程状态（new新建、Runnable可运行、Blocked锁阻塞、Waiting无限等待、Timed Waiting计时等待、Teminated被终止）、
线程状态切换（notify唤醒、sleep计时等待、wait无限等待、sleep不释放锁，wait释放锁）、
线程池（线程池概念、工作原理、Executors创建线程池、线程池提交Runnable任务/Callable任务）
死锁（死锁概念、产生死锁条件）
Lambda表达式（函数式编程、函数式接口、使用Lambda的前提、Lambda标准格式、无参数无返回值/有参数有返回值Lambda、Lambda省略写法规则）
Stream（流式思想、获取流：集合流/数组流/双列集合流、终结方法/非终结方法）
流模型操作方法（forEach遍历、count统计、filter过滤、limit取前n个、skip跳过前n个、map映射(转换)、concat组合(合并流)）
收集Stream结果（收集到集合/数组）

一、线程安全

多个线程在同时运行，这些线程同时运行同一段代码。程序每次运行结果和单线程运行结果一样，变量的值也和预期一样，就是线程安全的。

理解：多个线程在操作共享资源时仍然能得到正确的结果则称为线程安全，反则线程不安全。

1、线程不安全演示（卖票案例）

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)

需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

卖票逻辑分析

定义变量记录总票数：100
使用死循环保证能够卖完所有票
判断是否有剩余票数：有则卖一张，没有了则提示用户票卖完了

实现步骤分析

创建类实现Runnable接口
重写run方法：编写卖票逻辑的代码
创建接口实现类对象
根据实现类对象创建多个Thread对象：模拟多个窗口卖票
开启多个线程同时卖票

代码实现

模拟票：

public class Ticket implements Runnable {
   
	private int ticket = 100;
	
	//执行卖票操作
	@Override
	public void run() {
   
		//每个窗口卖票的操作，窗口永远开启
		while (true) {
   
			if (ticket > 0) {
    //有票 可以卖
				//出票操作，使用sleep模拟一下出票时间
				try {
   
					Thread.sleep(100);
				} catch (InterruptedException e) {
   
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			
				//获取当前线程对象的名字
				String name = Thread.currentThread().getName();
				System.out.println(name + "正在卖:" + ticket--); //先显示ticket数量，再减1
			}
		}
	}
}

测试类：

public class Demo {
   
	public static void main(String[] args) {
   
		//创建线程任务对象
		Ticket ticket = new Ticket();
		
		//创建三个窗口对象
		Thread t1 = new Thread(ticket, "窗口1");
		Thread t2 = new Thread(ticket, "窗口2");
		Thread t3 = new Thread(ticket, "窗口3");
		
		//同时卖票
		t1.start();
		t2.start();
		t3.start();
	}
}

结果分析

结果中出现这种现象：
在这里插入图片描述

卖出相同的票数，比如5这张票被卖了两回。
卖出不存在的票，比如0票与-1票，是不存在的。

几个窗口(线程)票数不同步，这种问题称为线程不安全。

小结

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作（减少/增加），一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步问题，否则可能出现线程不安全。

2、线程同步

线程同步就是为了解决线程不安全问题。
当我们使用多个线程访同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程不安全问题。
要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

线程同步解决卖票线程不安全问题

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着。
窗口1操作结束，窗口1、窗口2、窗口3才有机会进入代码去执行（窗口1操作完仍有机会继续操作）。
也就是说在某个线程修改共享资源时，其他线程不能修改该资源，只能等待该线程修改完毕同步之后（与其他线程同步到等待执行状态），才能去抢夺CPU资源完成对应的操作。保证了数据的同步性，解决了线程不安全的现象。

理解：线程同步，即所有线程同步到等待执行状态，才一同抢夺CPU资源。有某一个线程不是等待执行状态，其他线程都不能抢夺CPU资源。
共享资源即Runnable/Callabale接口实现类的成员变量

二、实现线程同步的三种方式

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。有三种方式完成同步操作

同步代码块（synchronized代码块）。
同步方法（synchronized修饰的方法）。
锁机制（ReentrantLock类）。

原子操作：所谓原子操作是指不会被线程调度机制打断的操作，这种操作一旦开始，就一直运行到结束，中间不会有任何context switch （切换到另一个线程）

1、同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示对这个区块的资源实行互斥访问。

同步代码块的原理：能够保证同一时间只有一个线程执行同步代码块的代码。

同步代码块格式

synchronized(同步锁){
   
	需要同步操作的代码
}

//通俗
synchronized(锁对象){
   
	操作共享资源的代码
}

同步锁:

对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

锁对象可以是任意类型。（可以随意创建一个对象作为锁）
多个线程对象要使用同一把锁。

在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。

同步代码块解决卖票案例的线程不安全问题

public class Ticket implements Runnable{
   
	private int ticket = 100;
	//创建对象作为锁
	Object lock = new Object();

	/*
	* 执行卖票操作
	*/
	@Override
	public void run() {
   
		//每个窗口卖票的操作，窗口永远开启
		while(true){
   
			//synchronized代码块（同步代码块）
			synchronized (lock) {
   
				if(ticket>0){
   //有票 可以卖
					//出票操作，使用sleep模拟一下出票时间
					try {
   
						Thread.sleep(50);
					} catch (InterruptedException e) {
   
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

					//获取当前线程对象的名字
					String name = Thread.currentThread().getName();
					System.out.println(name+"正在卖:"+ticket--);
				}
			}
		}
	}
}

使用了同步代码块后，线程不安全问题解决了。

2、同步方法

同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

线程使用同步方法，在run()里面调用同步方法。

同步方法的原理：能够保证同一时间只有一个线程执行方法体中的代码。

同步方法格式

public synchronized void method(){
   
	可能会产生线程安全问题的代码
}

//通俗
修饰符 synchronized 返回值类型 方法名(参数列表){
    
	操作共享资源的代码 
}

同步方法的同步锁

同步方法隐藏了同步锁，不用自己再创建对象作为锁。
对于非static方法，同步锁就是this（调用当前方法的对象）。
对于static方法，我们使用当前方法所在类的字节码对象(类名.class)作为同步锁。

同步方法与静态同步方法各自的锁对象是谁：
https://blog.csdn.net/Fighting_mjtao/article/details/83061419

同步方法使用示例

public class Ticket implements Runnable{
   
	private int ticket = 100;
		//执行卖票操作
		@Override
		public void run() {
   
		//每个窗口卖票的操作，窗口永远开启
		while(true){
   
			sellTicket();
		}
	}

	//锁对象 是 谁调用这个方法 就是谁
	//隐含 锁对象 就是 this
	public synchronized void sellTicket(){
   
		if(ticket>0){
   //有票 可以卖
			//出票操作。使用sleep模拟一下出票时间
			try {
   
				Thread.sleep(100);
			} catch (InterruptedException e) {
   
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			//获取当前线程对象的名字
			String name = Thread.currentThread().getName();
			System.out.println(name+"正在卖:"+ticket--);
		}
	}
}

静态同步方法示例

要同步静态方法，需要一个用于整个类对象的锁，这个对象是就是这个类（XXX.class)。

public static synchronized int setName(String name){
   
      Xxx.name = name;
}

等价于

public static int setName(String name){
   
      synchronized(Xxx.class){
   
            Xxx.name = name;
      }
}

java synchronized静态同步方法与非静态同步方法，同步语句块：
https://www.cnblogs.com/csniper/p/5478572.html

3、Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外Lock更强大，更能体现面向对象。

ReentrantLock类（Lock锁的同步锁对象）

Lock锁的同步锁，是用实现Lock接口的ReentrantLock类对象作为锁对象。
Lock接口的实现类主要有ReentrantLock、ReadLock和WriteLock，后两者接触的不多。

ReentrantLock类对象又叫互斥锁、可重入锁

锁分类

线程安全用到锁，MySql也用到锁。

互斥锁：指的是一次最多只能有一个线程持有的锁，如Lock锁
可重入锁：指定是某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。synchronized和ReentrantLock都是可重入锁。（理解：可重入锁类似for嵌套，在第一次获得锁之后，还可以可以继续获得这个锁（for循环还可以写for循环），而不产生死锁。重入锁和互斥锁不冲突，等于同一线程不停获得锁。）

Java 中的悲观锁和乐观锁的实现
https://www.cnblogs.com/zhaoyan001/p/8349547.html
可重入锁详解（什么是可重入）
https://blog.csdn.net/w8y56f/article/details/89554060
一文足以了解什么是 Java 中的锁
https://baijiahao.baidu.com/s?id=1653365466720197481&wfr=spider&for=pc
自旋锁、阻塞锁、可重入锁、悲观锁、乐观锁、读写锁、偏向所、轻量级锁、重量级锁、锁膨胀、对象锁和类锁
https://blog.csdn.net/a314773862/article/details/54095819

Lock加锁、释放锁方法

Lock锁也称同步锁，对加锁与释放锁的操作进行方法化了

public void lock()  ：加同步锁。

public void unlock() ：释放同步锁。

Lock接口使用注意事项
获取锁和释放锁的代码必须成对出现

Lock实现线程安全的格式

Lock l = new ReentrantLock(); //创建锁对象
//获得锁
l.lock();

try{
   
    // 操作共享资源代码
} catch(...){
   

}finally{
   
	//释放锁
    l.unlock();
}

Lock锁解决卖票线程不安全示例

public class Ticket implements Runnable{
   
	private int ticket = 100;
	Lock lock = new ReentrantLock();

	//执行卖票操作
	@Override
	public void run() {
   
		
		//每个窗口卖票的操作，窗口永远开启
		while(true){
   
			lock.lock();
			
			if(ticket>0){
    //有票可以卖
				//出票操作，使用sleep模拟一下出票时间				
				try {
   
					Thread.sleep(50);
				} catch (InterruptedException e) {
   
					
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
				//获取当前线程对象的名字
				String name = Thread.currentThread().getName();
				System.out.println(name+"正在卖:"+ticket--);
			}
			
			lock.unlock();
		}
	}
}

小结

如何选择synchronized关键字和Lock接口

相同点：都是用来实现线程安全
不同点：
synchronized关键字是很早出现的技术，Lock接口是JDK1.5新特性
如果资源竞争不激烈(线程数量少)，则Lock和synchronized效率几乎一样，没有区别。
如果资源竞争激烈(线程数量多)，则Lock的效率会远远高于synchronized

如何判断代码是否是共享资源

资源就是变量，如果变量是局部变量则不是共享资源，不需要加锁。
如果是成员变量：如果会对该成员变量进行修改，则必须加锁，否则也不需要加锁。

三、线程状态

线程状态就是线程由生到死的完整过程。了解线程状态是技术素养和面试的要求。

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在API中 java.lang.Thread.State这个枚举中给出了了六种线程生命周期的状态：
在这里插入图片描述

线程状态运行流程

在这里插入图片描述
不需要去研究这几种状态的实现原理，只需知道在做线程操作中存在这样的状态。
新建与被终止还是很容易理解的，我们就研究一下线程从Runnable（可运行）状态与非运行状态之间的转换问题。

四、线程可运行状态与非运行状态之间的转换

可运行状态：Runnable(可运行)
非运行状态：Waiting(无限等待)、Timed Waiting(计时等待)

1、睡眠sleep方法

切换Timed Waiting（计时等待）状态

public static void sleep(long time) 
	让当前线程进入到睡眠状态，经过指定毫秒后自动醒来继续执行

代码示例

主线程休眠1秒

public class Test{
   
	public static void main(String[] args){
   
		for(int i = 1;i<=5;i++){
   
			Thread.sleep(1000);
			System.out.println(i)
		}
	}
}

这时我们发现主线程执行到sleep方法会休眠1秒后再继续执行。

2、无限等待wait方法、随机唤醒notify方法

wait()、notify()都是Object类的方法。因为synchronized中的这把锁可以是任意对象，所以任意对象都可以调用wait()和notify()；所以wait和notify属于Object。

为什么wait()和notify()属于Object类：https://www.cnblogs.com/lirenzhujiu/p/5927241.html

wait()、notify()必须都由锁对象调用。

无限等待和随机唤醒方法

public void wait() 
	让当前线程进入到等待状态 此方法必须由锁对象调用

public void notify() 
	唤醒当前锁对象上等待状态的线程 此⽅方法必须锁对象调⽤用.

代码示例

" " 空字符串作为锁对象

public class Demo1_wait {
    
	public static void main(String[] args) throws InterruptedException {
   
		//步骤1: 子线程开启，进入无限等待状态，没有被唤醒，无法继续运行.
		new Thread(() -> {
   
			try {
   
				System.out.println("begin wait ....");
				synchronized ("") {
   
					"".wait();
				}
				System.out.println("over");
			} catch (Exception e) {
   
				e.printStackTrace();
			}
		}).start();
	
		//步骤2: 加入如下代码后, 3秒后执行notify⽅方法, 唤醒wait中线程.
		Thread.sleep(3000);
		new Thread(() -> {
   
			try {
   
				synchronized ("") {
   
					System.out.println("唤醒");
					"".notify();
				}
			} catch (Exception e) {
   
				e.printStackTrace();
			}
		}).start();
	}
}

面试题：sleep和wait的区别

sleep睡眠时不会释放锁。
wait等待时会释放锁。

3、等待与唤醒，线程交替案例（包子铺卖包子）

案例说明：
包子铺生产一个包子，吃货吃一个包子，包子铺再生产一个包子，吃货再吃一个包子…

实现步骤：

创建集合：用来存储包子
创建包子铺线程：负责生产包子
创建吃货线程：负责吃包子
同时启动包子铺和吃货线程

代码实现

包子铺线程：生产包子
list作为锁对象

public class BaoZiPuThread implements Runnable {
   

    // 创建集合：存储包子
    private ArrayList<String> list;

    public BaoZiPuThread(ArrayList<String> list) {
   
        this.list = list;
    }

    private int index = 0;
    
    // 需求：生产包子代码
    @Override
    public void run(

最低0.47元/天解锁文章

Jinniu00

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础加强重温_08：线程不安全、线程同步、线程状态、线程状态切换、线程池（Executors类、newFixedThreadPool）、死锁、Lambda表达式、Stream

摘要Java基础加强重温_08：线程安全（线程安全概念、线程不安全案例）、线程同步（同步代码块、同步方法、Lock锁，锁对象）、线程状态（new新建、Runnable可运行、Blocked锁阻塞、Waiting无限等待、Timed Waiting计时等待、Teminated被终止）、线程状态切换（notify唤醒、sleep计时等待、wait无限等待、sleep不释放锁，wait释放锁）...
复制链接

扫一扫

专栏目录