Java_多线程（二十七）——多线程（线程安全、同步、Lock接口、死锁、等待唤醒机制）

最新推荐文章于 2023-06-26 17:40:37 发布
最新推荐文章于 2023-06-26 17:40:37 发布
阅读量194 收藏 1
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40243295/article/details/112920322
版权

目录

第一章 多线程

1.1 线程安全

1.2 线程同步（线程安全处理Synchronized）

1.2.1 同步代码块

1.2.2 同步方法（建议使用）

1.3 Lock接口

1.4 死锁

1.5  等待唤醒机制

第二章 总结

第一章 多线程

1.1 线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

 我们通过一个案例，演示线程的安全问题：

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “功夫熊猫3”这场电影票(多个窗口一起卖这100张票)

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

测试类：

package day27.demo1;

/*
 * 多线程并发访问同一个数据资源
 * 3个线程,对一个票资源,出售
 */
public class ThreadDemo {
	public static void main(String[] args) {
		//创建Runnable接口实现类对象
		Tickets t = new Tickets();
		//创建3个Thread类对象,传递Runnable接口实现类
		Thread t0 = new Thread(t);
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		
		t0.start();t1.start();t2.start();
		
	}
}

 模拟票：

package day27.demo1;

public class Tickets implements Runnable{
	
	//定义出售的票源
	private int ticket = 100;
	private Object obj = new Object();
	
	public void run(){
		while(true){
			//对票数判断,大于0,可以出售,变量--操作
				if( ticket > 0){
					System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
				}
			}
		}
	}

运行结果： 

 

run方法只有一个，但要进栈3次，使用的是同一个票源ticket。假如票剩1张是，t0先抢占了cpu，刚判断完ticket>0，但还未执行ticket--时，cpu被t1抢占，此时ticket依然大于0。此时这种情况会导致最后输出的ticket出现负数。这是线程不安全。

 若我们用休眠来演示cpu被抢占：

只需要修改模拟票类：

package day27.demo1;

/*
 *  通过线程休眠,出现安全问题
 */
public class Tickets implements Runnable{
	
	//定义出售的票源
	private int ticket = 100;
	private Object obj = new Object();
	
	public void run(){
		while(true){
			//对票数判断,大于0,可以出售,变量--操作
				if( ticket > 0){
					try{
					   Thread.sleep(10);
					}catch(Exception ex){}
					System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
				}
			}
		}
	}

运行结果：

 

1.2 线程同步（线程安全处理Synchronized）

java中提供了线程同步机制，它能够解决上述的线程安全问题。

线程同步的方式有两种：

方式1：同步代码块

方式2：同步方法

 

1.2.1 同步代码块

同步代码块: 在代码块声明上，加上synchronized。

synchronized (锁对象) {

    可能会产生线程安全问题的代码

}

同步代码块中的锁对象可以是任意的对象；

此对象不能写匿名对象，因为每次while循环，匿名对象就变了，因此必须写有名对象。即多个线程时，要使用同一个锁对象才能够保证线程安全。

使用同步代码块，对电影院卖票案例中Ticket类进行如下代码修改：

package day27.demo1;

/*
 *  通过线程休眠,出现安全问题
 *  解决安全问题,Java程序,提供技术,同步技术
 *  公式:
 *    synchronized(任意对象){
 *      线程要操作的共享数据
 *    }
 *    同步代码块
 */
public class Tickets implements Runnable{
	
	//定义出售的票源
	private int ticket = 100;
	private Object obj = new Object();
	
	public void run(){
		while(true){
			//线程共享数据,保证安全,加入同步代码块
			synchronized(obj){
			//对票数判断,大于0,可以出售,变量--操作
				if( ticket > 0){
					try{
					   Thread.sleep(10);
					}catch(Exception ex){}
					System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
				}
			}
		}
	}
}

运行结果：

 

1. 线程遇到同步代码块后，线程判断还有没有同步锁。若有同步锁，则此线程获取锁，进入同步代码块中，去执行代码，执行完毕后，出同步代码块，并且将锁对象还回去。   若没有锁，则此线程被挡在同步代码块的外面。

2. 通过运行我们明显感觉到执行速度变慢。这是因为这是线程安全的，执行速度会变慢。

     因为有了同步之后，线程每次要判断同步锁，获取锁，使用完之后还有释放锁，导致程序运行速度降低。

 

1.2.2 同步方法（建议使用）

同步方法：在方法声明上加上synchronized

比同步代码块好，代码量少。

public synchronized void method(){

   可能会产生线程安全问题的代码

}

同步方法中，锁对象是 this。

	//同步方法中的对象锁,是本类对象引用 this
	public   void payTicket(){
		//静态方法中的成员也要为静态，因此ticket设为静态
		synchronized(this) {
		if( ticket > 0){
			try{
			   Thread.sleep(10);
			}catch(Exception ex){}
			System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
		}
		}
}

静态里面不能写this和super，因为静态是类的共享数据，不属于对象。而this属于对象引用，并且静态优先于非静态存在。

静态的同步方法中，锁对象是本类类名.class。

	//静态方法,同步锁,是本类类名.class属性	
	public  static void payTicket(){
		
		//静态方法中的成员也要为静态，因此ticket设为静态
		synchronized(Tickets1.class)//与反射有关 {
		if( ticket > 0){
			try{
			   Thread.sleep(10);
			}catch(Exception ex){}
			System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
		}
		}
}

使用同步方法，对电影院卖票案例中Ticket类进行如下代码修改：

package day27.demo1;

/*
 *  采用同步方法形式,解决线程的安全问题
 *  好处: 代码简洁
 *  将线程共享数据,和同步,抽取到一个方法中
 *  在方法的声明上,加入同步关键字
 *  
 *  问题:
 *    同步方法有锁吗,肯定有,同步方法中的对象锁,是本类对象引用 this
 *    如果方法是静态的呢,同步有锁吗,绝对不是this
 *    锁是本类自己.class 属性
 *    静态方法,同步锁,是本类类名.class属性
 */
public class Tickets1 implements Runnable{

	//定义出售的票源
	private  static int ticket = 100;
	
	public void run(){
		while(true){
			payTicket();
		}
	}
	
	public  synchronized void payTicket(){	
			if( ticket > 0){
				try{
				   Thread.sleep(10);
				}catch(Exception ex){}
				System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
			}
		
	}
	
//	//静态方法,同步锁,是本类类名.class属性	
//	public  static void payTicket(){
//		
//		//静态方法中的成员也要为静态，因此ticket设为静态
//		synchronized(Tickets1.class)//与反射有关 {
//		if( ticket > 0){
//			try{
//			   Thread.sleep(10);
//			}catch(Exception ex){}
//			System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
//		}
//		}
//}
	
//	//同步方法中的对象锁,是本类对象引用 this
//	public   void payTicket(){
//		//静态方法中的成员也要为静态，因此ticket设为静态
//		synchronized(this) {
//		if( ticket > 0){
//			try{
//			   Thread.sleep(10);
//			}catch(Exception ex){}
//			System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
//		}
//		}
//}
	
}

 

1.3 Lock接口

public  synchronized void payTicket(){	
			if( ticket > 0){
				try{
				   Thread.sleep(10);
				}catch(Exception ex){}
				System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
			}
		
	}

此代码中，有以下两个问题：

1. 何时获取锁我们知道，但是何时释放锁，我们并不知道。

2.若在sleep过程中，真的发生了异常，catch后此线程执行结束，但是锁没有释放，因为不出同步块，锁不释放。

因此出现了Lock来替换synchronized。

Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。

Lock接口中的常用方法：

 

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。

我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket类进行如下代码修改：

package day27.demo1;

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

/*
 *  使用JDK1.5 的接口Lock,替换同步代码块,实现线程的安全性
 *  Lock接口方法:
 *     lock() 获取锁
 *     unlock()释放锁
 *  实现类ReentrantLock
 */
public class Tickets_2 implements Runnable{
	
	//定义出售的票源
	private int ticket = 100;
	//在类的成员位置,创建Lock接口的实现类对象
	//写在run中不可（若有多个线程，则有多个锁，此应为共享资源），写在while循环中每次循环生成的锁不同。
	private Lock lock = new ReentrantLock();
	
	public void run(){
		
		while(true){
			//调用Lock接口方法lock获取锁
		    lock.lock();
			//对票数判断,大于0,可以出售,变量--操作
				if( ticket > 0){
					try{
					   Thread.sleep(10);
					   System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
					}catch(Exception ex){
						
					}finally{
						//释放锁,调用Lock接口方法unlock
						lock.unlock();
					}
				}
	
			
		}
	}
}

 

1.4 死锁

同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

synchronzied(A锁){

    synchronized(B锁){        

    }

}

外部类要访问非静态成员需要对象调，但是此方法为私有的，外部类不能创建对象。因此外部类可以静态调，不需要对象。

1. 定义锁对象类

package day27.demo1;

public class LockA {
	private LockA(){}
	
	public  static final LockA locka = new LockA();
}

package day27.demo1;

public class LockB {
	private LockB(){}
	
	public static final LockB lockb = new LockB();
}

 2.线程任务类 

package day27.demo1;


public class DeadLock implements Runnable{
	private int i = 0;
	public void run(){
		while(true){
        //随着循环次数增多，发生死锁的几率就增加了
			if(i%2==0){
				//先进入A同步,再进入B同步
				synchronized(LockA.locka){
                //外部类不能创建对象,但是外部类可以静态调 LockA.locka
					System.out.println("if...locka");
					synchronized(LockB.lockb){
						System.out.println("if...lockb");
					}
				}
			}else{
				//先进入B同步,再进入A同步
				synchronized(LockB.lockb){
					System.out.println("else...lockb");
					synchronized(LockA.locka){
						System.out.println("else...locka");
					}
				}
			}
			i++;
		}
	}
}

3.测试类

package day27.demo1;
public class DeadLockDemo {
	public static void main(String[] args) {
		DeadLock dead = new DeadLock();
		Thread t0 = new Thread(dead);
		Thread t1 = new Thread(dead);
		t0.start();
		t1.start();
	}
}

运行结果： 

 

1.5  等待唤醒机制

线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制所涉及到的方法：

  1. wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。
  2. notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。
  3. notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

其实，所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。

仔细查看JavaAPI之后，发现这些方法 并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？

因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。

建在while循环内不对，没次循环，建立不同的Resource对象。 建在run内也不合适，若有三个线程，三个run，每个run都有自己的Resource，不合适。Resource应该为共享数据。

输出null..null的解决方法：

方法一：死锁中的静态调用

方法二：在测试类中创建一个对象，给input和output传参。 

但依然出现问题，lisi性别是nv，但打印出为男。 

性别与名字不匹配的问题，解决方法：写和读都要加锁，都为资源锁，不能为this锁。

需要锁的对象调用wait() 

输入线程任务类：

package day27.demo1;
/*
 *  输入的线程,对资源对象Resource中成员变量赋值
 *  一次赋值 张三,男
 *  下一次赋值 lisi,nv
 */
public class Input implements Runnable {
	private Resource r ;
	
	public Input(Resource r){
		this.r = r;
	}
	
	public void run() {
		int i = 0 ;
		while(true){
		  synchronized(r){
			  //标记是true,等待
			    if(r.flag){
			    	try{r.wait();}catch(Exception ex){}
			    }
			  
				if(i%2==0){
					r.name = "张三";
					r.sex = "男";
				}else{
					r.name = "lisi";
					r.sex = "nv";
				}
				//将对方线程唤醒,标记改为true
				r.flag = true;
				r.notify();
		  }
			i++;
		}
	}

}

输出线程任务类：

package day27.demo1;
/*
 *  输出线程,对资源对象Resource中成员变量,输出值
 */
public class Output implements Runnable {
	private Resource r ;
	
	public Output(Resource r){
		this.r = r;
	}
	public void run() {
		while(true){
		  synchronized(r){	
			  //判断标记,是false,等待
			if(!r.flag){
				try{r.wait();}catch(Exception ex){}
		    }
			System.out.println(r.name+".."+r.sex);
			//标记改成false,唤醒对方线程
			r.flag = false;
			r.notify();
		  }
		}
	}

}

模拟资源类： 

package day27.demo1;
/*
 *  定义资源类,有2个成员变量
 *  name,sex
 *  同时有2个线程,对资源中的变量操作
 *  1个对name,age赋值
 *  2个对name,age做变量的输出打印
 */
public class Resource {
	public String name;
	public String sex;
	public boolean flag = false;
}

测试类： 

package day27.demo1;
/*
 *  开启输入线程和输出线程,实现赋值和打印值
 */
public class ThreadDemo3{
	public static void main(String[] args) {
		
		Resource r = new Resource();
		
		Input in = new Input(r);
		Output out = new Output(r);
		
		Thread tin = new Thread(in);
		Thread tout = new Thread(out);
		
		tin.start();
		tout.start();
	}
}

运行结果：

 

第二章 总结

同步锁

多个线程想保证线程安全，必须要使用同一个锁对象

同步代码块

         synchronized (锁对象){

    可能产生线程安全问题的代码

}

同步代码块的锁对象可以是任意的对象

同步方法

         public synchronized void method()

              可能产生线程安全问题的代码

}

                           同步方法中的锁对象是 this

 

 

静态同步方法

public synchronized void method()

              可能产生线程安全问题的代码

}

静态同步方法中的锁对象是 类名.class

 

多线程有几种实现方案，分别是哪几种?

         a, 继承Thread类

         b, 实现Runnable接口

         c, 通过线程池，实现Callable接口

 

同步有几种方式，分别是什么?

         a,同步代码块

         b,同步方法

           静态同步方法

为什么wait(),notify(),notifyAll()等方法都定义在Object类中

         锁对象可以是任意类型的对象

 

kww_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Windbg分析多线程临界区死锁问题分享
dvlinker的技术专栏
01-03 4万+
使用Windbg分析多线程临界区死锁问题分享。
Java多线程遇到死锁三招彻底解决
技术专家
11-25 2297
Java多线程遇到死锁三招彻底解决多次岸城
Java中多线程安全、同步、死锁、等待唤醒机制
ONESTARの博客
07-19 2521
目录 一、线程安全问题 二、线程同步 1、同步代码块 2、同步方法 三、死锁 四、Lock 接口 五、等待和唤醒机制 一、线程安全问题 如果有多个线程在同时运行，而这些线程可能会同时运行这段代码，程序每次运行结果和单线程运行的结果是一样的，而且程序中的变量值和和预期的一样，那么线程就是安全的，如果不是，则线程不安全。 下面通过售票的案例来理解一下线程安全问题 //模拟售票类...
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
一只文森特
04-25 1663
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
Java 多线程 —— 同步代码块（解决线程安全问题)
一纸春秋的博客
10-23 1万+
目录火车站抢票问题同步代码块同步方法（this锁）同步方法，在public的后面加上synchronized关键字this锁静态同步方法 火车站抢票问题 由于现实中买票也不会是零延迟的，为了真实性加入了延迟机制，也就是线程休眠语句 package test.MyThread.ticketDemo; public class RunnableThread implements Runnable{ private int ticket = 100; @Override public v
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
【并发编程】多线程安全问题，如何避免死锁
阿Q的小窝
06-26 2081
本文我们从大家熟知的线程和进程入手，通过对比他俩的使用场景、代码使用来方便记忆。随后对线程的创建方式以及生命周期进行了详细的讲解。然后介绍了线程使用过程中的一些方法，方便大家更好的入手。最后对多线程的安全问题和死锁问题进行了总结.
JAVA多线程之并发与同步，Lock与Syncronized
csdn_aiyang的博客
03-23 2万+
说到线程，就不得不先说线程和进程的关系。进程是系统的执行单位，一般一个应用程序即是一个进程，程序启动时系统默认有一个主线程，即是UI线程，我们知道不能做耗时任务，否则ANR程序无响应。这时需要借助子线程实现，即多线程。由于线程是系统CPU的最小单位，用多线程其实就是为了更好的利用cpu的资源。一、多线程创建方式//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源xx.start();//启动线程，run函数运行@Override@Override。
Java——多线程高并发系列之Lock、ReentrantLock
★★光亭★★
06-09 7296
Java——多线程高并发系列之Lock、ReentrantLock
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
Java多线程--避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
JAVA-JavaThreadProgramming-Sams.zip_JAVA 设计_java 多线程_java 线程_多线程
09-14
Java提供了多种同步机制来解决多线程环境下的数据安全问题，如synchronized关键字、 volatile变量、Lock接口（如ReentrantLock）以及Semaphore信号量等。synchronized提供了内置锁，可以保证同一时刻只有一个线程...
Java多线程 线程同步与死锁
08-30
Java多线程 线程同步与死锁 Java多线程是一种编程技术，允许多个线程同时执行，以提高程序的执行效率和响应速度。但是，多线程编程也存在一些安全问题，例如线程同步和死锁问题。 线程同步是指多个线程之间的协作...
Java多线程基础——Lock类
08-31
Java多线程基础中的Lock类提供了比`synchronized`更强大的同步控制能力。Lock是一个接口，它定义了比`synchronized`更灵活的锁定机制，允许更细粒度的控制。在Java 1.5及之后的版本中引入，Lock类的主要目的是提高...
javaduoxiancheng.rar_多线程 java
09-24
"javaduoxiancheng.rar_多线程 java"这个压缩包文件可能包含了关于Java多线程编程的相关资料和示例代码，帮助开发者深入理解和实践Java的多线程同步机制。 首先，我们需要了解Java中线程的创建方式。Java提供了两种...
PTA题目整理（java）
qq_40243295的博客
01-06 1万+
1.人名地名排序 （10 分） 从键盘输入若干人名、地名或者国家名，要求按照升序排序之后输出。 package pra_end; import java.util.Arrays; import java.util.Scanner; public class sort { public static void main(String[] args) { Scanner in=new...
输出a到b之间的素数，并且求和（自定义函数）——java
qq_40243295的博客
09-25 5375
题目描述： 键盘输入两个整数a,b为要查找的起始和终止范围。程序输出此范围的所以素数，以及和 考察知识点：自定义函数的定义以及调用 代码：  package spoc; import java.util.Scanner; public class sum_prime { //b以内素数求和 public static void isPrime(int a,int b){ int...
数组的三种比较方式的区别： ==，a.equals(b)，和Arrays.equals(a,b)
qq_40243295的博客
03-23 5133
数组的三种比较的 ==，a.equals(b)，和Arrays.equals(a,b) 若a，b都为数组，则： a=b ，比较的是地址 a.equals(b) 比较的是地址 Arrays.equals(a, b) 比较的是元素内容 原因： int没有定义equals，而Object类中的equals方法是用来比较“地址”的。 数组a==数组b，比较的是地址，两个变量的内存地址不一样，也就是说它们指向的对象不 一样。 当比较两个字符串的时候，它使用的是String类下的equa..
Java_管家婆项目（三十一）——管家婆家庭记账软件（项目环境搭建、功能模块、代码）、后附网盘链接
qq_40243295的博客
01-27 3596
管家婆家庭记账软件 第一章项目介绍 1.1 项目安排 1.1.1 项目目标 本项目为JAVAEE基础班综合项目，包含了若干个知识点，达到将基础班所学知识综合使用，提高了我们对项目的理解与知识点的运用。 熟练View层、Service层、Dao层之间的方法相互调用操作、 熟练dbutils操作数据库表完成增删改查 通过本项目，让我们了解公司项目开发的流程，充分的掌握项目需求分析、设计与功能的代码实现。提高同学们独立分析需求与功能实现的能力。 1.2 项目功能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值