超牛牪犇Java之同步代码块和锁的用法&死锁&如何停止线程

最新推荐文章于 2024-01-29 18:23:10 发布
最新推荐文章于 2024-01-29 18:23:10 发布
阅读量413 收藏
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EnchantedLLL/article/details/80585745
版权

一.同步代码块和锁

CPU是随机执行线程的 也就是说线程可以在方法的任何位置被停止执行(用极限位置去假设)

在多个线程访问共享数据时:

要保证同一时间 只有一个线程操作共享数据

(当一个线程操作数据时 其他线程不能操作 只能等着操作的线程操作完成之后才能继续进入操作数据)

Thread子类不能实现资源共享

用同步代码块(同步锁)来解决:

锁:任意对象(只有一把锁 多个线程使用的是通一把锁)

写法:

synchronized(锁){

        操作共享数据的代码

}

卖票的例子:

多个平台同时卖票 为了防止多个平台同时卖一张票

class TicketRunnable implements Runnable {
	// 声明票
	private int ticket = 50;
	// 声明锁对象 保证只有一把锁
	private Object obj = new Object();
	// 卖票 票--
	@Override
	public void run() {
		// 循环卖
		while (true) {
			// 同步锁
			synchronized (obj) {
				// 判断卖完没
				if (ticket > 0) {
					// 为了让测试结果更明显 加个休眠
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					// 卖票
					System.out.println(Thread.currentThread().getName() 
							+ "****" + ticket);
					// 卖一张 少一张
					ticket--;
				} else {
					// 卖光了 结束循环
					break;
				}
			}
			// 让出CPU的执行资源(随机让出 随机性)
			Thread.yield();
		}
	}
}

在主线程中创建三个子线程 相当于三个平台卖票:

public static void main(String[] args) {
	// 创建三个线程
	TicketRunnable runnable = new TicketRunnable();
	Thread t1 = new Thread(runnable);
	Thread t2 = new Thread(runnable);
	Thread t3 = new Thread(runnable);
	// 开启线程
	t1.start();
	t2.start();
	t3.start();
}

那么同步代码块是怎么做到一个线程执行代码时 其他线程在外面等待的?

同步代码块的规则:

当线程进入同步代码块的时候 先看一下有没有锁

如果有锁 就近入同步代码块中执行代码 进去的同时 会获取这把锁

当执行完毕 出同步代码块时 会将这把锁释放还回去

如果没锁 线程在同步代码块前等待(等着有锁才能进)

二.同步方法

作用和同步代码块一样

也是用synchronized关键字 只是该关键字声明在方法上

同一时间只能有一个线程进入到同步方法中 执行代码

同步方法中 也是写操作共享数据的代码

把上面的例子用同步方法来写:

用接口实现线程的方式

在接口的实现类中再写一个同步方法 如下:

class TicketRunnable1 implements Runnable {
	// 声明票
	private  static int ticket = 50;
	// 卖票 票--
	@Override
	public void run() {
		// 循环卖
		while (true) {
				// 判断卖完没
				if (sellTicket()) {
					break;
				}
			}
			// 让出CPU的执行资源(随机让出 随机性)
			Thread.yield();
		}
	//声明同步方法
	public synchronized boolean sellTicket() {
		if (ticket >= 0) {
			// 为了让测试结果更明显 加个休眠
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 卖票
			System.out.println(Thread.currentThread().getName() 
					+ "****" + ticket);
			// 卖一张 少一张
			ticket--;
			return false;
		} else {
			// 卖光了 结束循环
			System.out.println("票已售空");
			return true;
		}
	}
}

几个小问题:

1.同步方法怎么处理的 有没有锁 锁是什么?

有锁 处理方式和同步代码块是一样的 锁是同步的对象(成员)方法 this()本类的对象 

2.静态方法能不能加锁?

能

3.静态方法的锁是this吗?

不是 (静态方法不能使用this) 静态方法使用的锁是类锁  类名.class表示这个类

三.锁类 ReentranLock

JDK1.5的Lock接口 使用实现类ReentrantLock

方法:

lock();获取锁

unlock();释放锁 保证锁一定会被释放

使用前提和同步代码块一样 要保证用的是同一把锁

使用格式:

try{

    操作共享数据的代码

}finally{

    释放锁

}

还是上面的例子 用锁类的方法来写:

class TicketRunnable2 implements Runnable {
	// 声明票
	private int ticket = 50;
	//声明锁 保证同一把
	private ReentrantLock lock = new ReentrantLock();
	// 卖票 票--
	@Override
	public void run() {
		// 循环卖
		while (true) {
			lock.lock();
			try {
				// 判断是否卖完
				if (ticket >= 0) {
					// 为了让测试结果更明显 加个休眠
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					// 卖票
					System.out.println(Thread.currentThread().getName() 
							+ "****" + ticket);
					// 卖一张 少一张
					ticket--;
				} else {
					// 卖光了 结束循环
					break;
				}
			} catch (Exception e) {
				// TODO: handle exception
			}finally {
				lock.unlock();
			}	
			// 让出CPU的执行资源(随机让出 随机性)
			Thread.yield();
		}
	}
}
Thread.yield();方法可以让出CPU的执行资源(随机让出 随机性)

四.死锁

前提:

1. 必须要有同步锁的嵌套

        synchronized(){

                    synchronized(){

                    }

        }

2. 锁对象要唯一(使用的是同一把锁)

两把锁都要保证唯一

测试:

创建两个锁类用来创建锁对象

//创建A锁
class LockA{
	//为了唯一 不让外人创建 自己创建
	private LockA(){
		
	}
	//定义一个常量
	//能在外界获取到 但是不能修改
	public static final LockA LOCK_A = new LockA();
}
//创建B锁
class LockB{
	//为了唯一 不让外人创建 自己创建
	private LockB(){
		
	}
	//定义一个常量
	//能在外界获取到 但是不能修改
	public static final LockB LOCK_B = new LockB();
}

创建一个接口实现类来创建线程

class DieLockRunnable implements Runnable{
	//声明一个标记
	private boolean isFlag = true;
	//第一次 先进A锁再进B锁
	//下一次 先进B锁再进A锁
	@Override
	public void run() {
		//死循环 为了增加死锁的几率
		while (true) {
			if (isFlag) {
				//A -> B
				synchronized (LockA.LOCK_A) {
					System.out.println("我是if的LOCK_A锁");
					synchronized (LockB.LOCK_B) {
						System.out.println("我是if的LOCK_B锁");
					}
				}
			}else {
				//B -> A
				synchronized (LockB.LOCK_B) {
					System.out.println("我是else的LOCK_B锁");
					synchronized (LockA.LOCK_A) {
						System.out.println("我是else的LOCK_A锁");
					}
				}
			}
			//修改标记
			isFlag = !isFlag;
		}	
	}
}

五.线程的停止问题

stop()方法停止线程已经过时 不推荐使用

interrupt()方法 中断线程

interrupt方法的作用:

1.调用interrupt方法时 线程中有wait()/sleep()等方法 这时会抛出一个异常

        InterruptException异常 并且清除中断状态

2.调用interrupt方法时 线程中没有上述方法 这时会设置(改变)中断状态的值(true --> false)

用标记法中断线程:

用接口类的方法创建线程

class InterruptRunnable implements Runnable{
	//声明一个标识 用来关闭或者停止线程
	public boolean isFlag = false;
	@Override
	public void run() {
		//直接使用中断状态来中断线程
		//Thread.currentThread().isInterrupted()
		while (!isFlag) {
			//休眠
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		}
	}	
}
public static void main(String[] args) {
	InterruptRunnable runnable = new InterruptRunnable();
	Thread t1 = new Thread(runnable);
	t1.start();
	//给子线程几秒的执行时间 然后再中断线程
	try {
		Thread.sleep(3000);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	//标记中断线程
	runnable.isFlag = true;
	System.out.println("中断线程");
	try {
		Thread.sleep(1000);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	System.out.println("主线程结束");
}
wait()方法是Object类中的方法 是让线程等待 并且如果没有被唤醒 就会一直等待下去

直接使用wait()方法会出现异常 IllegalMonitorStateException

注意:wait()方法 必须使用锁对象去调用

当子线程中修改了状态 不能及时同步到主线程中

这时可以使用volatile关键词 让线程中的这个状态信息可以及时得到修改

class VolRunnable implements Runnable{
	//当子线程中修改了状态 不能及时同步到主线程中
	//这时可以使用volatile关键词 让线程中的这个状态信息 可以及时得到修改
	//标记
	public volatile boolean isFlag = false;
	//声明一个变量 记录 什么时候更改状态
	private int num = 0;
	@Override
	public void run() {
		while (!isFlag) {
			num++;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if (num > 5) {
				//更改中断状态
				isFlag = true;	
			}
			System.out.println(Thread.currentThread().getName() + "..run");
		}
	}
}


夏目家的猫
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java高并发编程实战15，Java同步代码块详解
学Java，找哪吒
05-22 8835
Java基础教程系列，打造精品专栏。
Java学习----同步代码块
hanxuya的博客
08-19 901
对于synchronized语句当Java源代码被javac编译成bytecode的时候，会在同步代码块的入口位置和退出位置分别插入monitorenter和monitorexit(2个)字节码指令。
java之多线程的加锁方式，死锁和线程停止（包含interrupt方法对wait，sleep方法的作用）
KongLingLei_08225的博客
09-19 798
一.加锁方式 1.解决需求的步骤： 需求：100张票,利用多线程进行卖票，方式有：窗口， 黄牛 ，网购。 多线程访问共享资源的访问 1.尝试写出需求。 2.分析出现的问题。 三个线程同时执行run方法,CPU执行资源随机分配。 线程在执行方法过程中,随时能进入受阻塞状态。 所以可以使用:假设线程停止的位置,来分析问题(找极限位置)。 3.想解决方案: 一个线程执行完买票操作,另一个线程才...
java 同步锁变量_java 同步锁：synchronized 关键字
weixin_35933582的博客
02-21 1106
简介synchronized关键字是Java里面最基本的同步手段，它经过编译之后，会在同步块的前后分别生成 monitorenter和 monitorexit字节码指令，这两个字节码指令都需要一个引用类型的参数来指明要锁定和解锁的对象；而直接使用 synchronized 关键字锁定方法时，生成的字节码指令里面并没有 monitorenter 和 monitorexit 这两个指令，而是为方法添加...
Java基础学习——Java线程（二）同步代码块、同步方法、Lock锁、死锁程序例子、不同类型的锁
skx1102195517的博客
12-30 2345
1
Java多线程--同步机制解决线程安全问题方式一：同步代码块
人生得意须尽欢
01-29 1428
Java多线程--同步机制解决线程安全问题方式一：同步代码块
java中的多线程、同步代码块、同步方法、锁
qq_51476492的博客
06-14 1597
说明：上述代码中实现了Runnable接口的类是放在了新建的Thread类中的，可以理解为实现了Runnable接口的类里面是线程要执行的任务，将任务交给执行线程。还需要注意，为了区分线程，需要给线程取名setName()，但是在实现了Runnable接口的类的run()方法不能直接使用getName()来获取线程名字，它是Thread类中的方法，解决方式是使用Thread的静态方法currentThread()来获取执行run()的当前线程，然后再使用getName()方法。创建子类的对象，并启动线程。
Java多线程（ Thread & Runnable）& Java同步代码块、同步方法、Lock锁
weixin_43294854的博客
06-14 379
实现多线程方式一:(继承Thread类) 1.创建Thread的子类，并重写run()方法； run():该方法体代表线程要完成的任务。（线程执行体） 2.调用start()方法执行线程 代码： public class MyThread extends Thread { //重写run方法设置线程任务 @Override public void run() { for (int i = 0; i <20 ; i++) { Sys
java中synchronized（同步代码块和同步方法）详解及区别
08-31
同步方法的整个方法体被视为同步代码块，所有访问该方法的线程都需要获取到相应的锁才能执行。 在给定的代码示例中，`methodA()` 是同步方法，`methodB()` 和 `methodC()` 是同步代码块。`methodB()` 使用 `this` ...
Java多线程之死锁的出现和解决方法
08-29
Java多线程之死锁的出现和解决方法 死锁是指多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不能正常运行。死锁的出现是由于不适当地运用“synchronized”...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例 Java中的锁对象Lock是java.util.concurrent.locks包下的接口，提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。它能以更优雅的方式处理线程...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
Java多线程--避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
Java多线程 线程同步与死锁
08-30
在多线程编程时，需要了解线程同步和死锁的概念，并且掌握相关的解决方法，以避免线程安全问题的出现。 知识点： * 多线程编程的概念 * 线程同步的概念 * 使用synchronized关键字实现线程同步 * 死锁的概念 * 使用...
Java同步方法及代码块
选择目标，然后保持热爱。
04-13 1789
同步方法及代码块：synchronized 同步方法 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和sychronized块 同步方法：public synchronized void method(int args){} synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的
JAVA同步代码块 & 同步方法
DoubleQ的博客
02-12 1707
为了解决多线程操作共享数据时产生的安全问题例如以下代码如果两个线程同时执行以上方法，同时访问或修改共享的变量ticket，就有可能会出现安全问题。
java中的synchronized（同步代码块和同步方法的区别）
一个人的江湖
03-30 4243
//下列两个方法有什么区别 public synchronized void method1(){}public void method2(){ synchronized (obj){} }synchronized用于解决同步问题，当有多条线程同时访问共享数据时，如果不进行同步，就会发生错误，java提供的解决方案是：只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能
同步代码块synchronized的使用与解析
猿小许的博客
09-10 858
Java 同步块（synchronized block）用来标记方法或者代码块是同步的。Java同步块用来避免竞争。本文介绍以下内容： Java同步关键字（synchronzied） 实例方法同步 静态方法同步 实例方法中同步块 静态方法中同步块 Java同步示例 Java同步关键字synchronized Java中的同步代码块用synchronized标记。同步代码块在Java中是同步在某个对象上。所有同步在一个对象上的同步代码块在同一时刻只能被一个线程进入操作。所有其他等待进入该同步块的线程将会被
Java多线程-同步机制解决线程安全问题方式一：同步代码块
01-29
- 案例2之static修饰：如果使用`static`方法或同步代码块，锁对象将是类本身，意味着所有实例共享同一把锁，可能导致线程阻塞。 - 案例2之类.class：使用`MyClass.class`作为锁对象，所有类的实例都会共享同一把锁...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值