线程共享数据的安全问题和死锁问题

最新推荐文章于 2024-09-22 11:46:40 发布
最新推荐文章于 2024-09-22 11:46:40 发布
阅读量797 收藏 1
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxd_1024/article/details/80494565
版权

多线程访问共享变量的时候会出现线程安全的问题

解决线程安全的问题：线程同步（同步代码块、同步方法、同步锁）

1.同步代码块

synchronized(同步监视器){
    //需要访问的共享数据
}
同步监视器 ： 俗称“锁”。可以使用任何对象充当。但是必须确定多个线程持有同一把锁（同一个对象）

2.同步方法

同步方法： ---- 隐式的锁 : this
          ----如果同步方法被静态（static）修饰后,隐式的锁是该类所属的字节码文件xxx.class（因为被static修饰，没有对象可调用此方法）
public synchronized void show(){
    //需要访问的共享数据
}

3.同步锁

public class MyRunnable implements Runnable {

	//static修饰 保证是共享资源  多个线程构造器传入同一个此对象则不必是static也可以
	public static int tick = 100;
	//创建一个锁 static修饰 保证是一个锁   多个线程构造器传入同一个此对象则不必是static也可以
	public static Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			//上锁
			lock.lock();
			try {
				if (tick > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
					}
					tick--;
					System.out.println(Thread.currentThread().getName() + "完成售票，余票为 ：" + tick);
				}
			} finally {
				//必须手动解锁
				lock.unlock();
			}
		}
	}
}
public class TestLock {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Thread thread1 = new Thread(new MyRunnable(),"aa");
		thread1.start();

		Thread thread2 = new Thread(new MyRunnable(),"bb");
		thread2.start();   
	}
}
public class TestThreadDeadLock {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		MyRunnable myRunnable = new MyRunnable();

		//下面两个线程构造器都传入同一个myRunnable 则不必用上面说的static修饰共享变量
		Thread thread1 = new Thread(myRunnable, "aa");
		thread1.start();

		Thread thread2 = new Thread(myRunnable, "bb");
		thread2.start();
	}
}

打印结果

aa完成售票，余票为 ：99
aa完成售票，余票为 ：98
bb完成售票，余票为 ：97
bb完成售票，余票为 ：96
aa完成售票，余票为 ：95
aa完成售票，余票为 ：94
aa完成售票，余票为 ：93
aa完成售票，余票为 ：92
bb完成售票，余票为 ：91
aa完成售票，余票为 ：90
bb完成售票，余票为 ：89
aa完成售票，余票为 ：88
bb完成售票，余票为 ：87
bb完成售票，余票为 ：86
bb完成售票，余票为 ：85
bb完成售票，余票为 ：84
aa完成售票，余票为 ：83
aa完成售票，余票为 ：82
bb完成售票，余票为 ：81
bb完成售票，余票为 ：80
bb完成售票，余票为 ：79
bb完成售票，余票为 ：78
bb完成售票，余票为 ：77
bb完成售票，余票为 ：76
aa完成售票，余票为 ：75
aa完成售票，余票为 ：74
aa完成售票，余票为 ：73
aa完成售票，余票为 ：72
aa完成售票，余票为 ：71
aa完成售票，余票为 ：70
aa完成售票，余票为 ：69
aa完成售票，余票为 ：68
aa完成售票，余票为 ：67
aa完成售票，余票为 ：66
aa完成售票，余票为 ：65
aa完成售票，余票为 ：64
aa完成售票，余票为 ：63
aa完成售票，余票为 ：62
aa完成售票，余票为 ：61
aa完成售票，余票为 ：60
aa完成售票，余票为 ：59
aa完成售票，余票为 ：58
aa完成售票，余票为 ：57
bb完成售票，余票为 ：56
bb完成售票，余票为 ：55
bb完成售票，余票为 ：54
bb完成售票，余票为 ：53
bb完成售票，余票为 ：52
bb完成售票，余票为 ：51
bb完成售票，余票为 ：50
bb完成售票，余票为 ：49
bb完成售票，余票为 ：48
bb完成售票，余票为 ：47
bb完成售票，余票为 ：46
bb完成售票，余票为 ：45
bb完成售票，余票为 ：44
bb完成售票，余票为 ：43
bb完成售票，余票为 ：42
bb完成售票，余票为 ：41
bb完成售票，余票为 ：40
bb完成售票，余票为 ：39
bb完成售票，余票为 ：38
bb完成售票，余票为 ：37
bb完成售票，余票为 ：36
bb完成售票，余票为 ：35
bb完成售票，余票为 ：34
aa完成售票，余票为 ：33
aa完成售票，余票为 ：32
aa完成售票，余票为 ：31
aa完成售票，余票为 ：30
aa完成售票，余票为 ：29
aa完成售票，余票为 ：28
bb完成售票，余票为 ：27
bb完成售票，余票为 ：26
bb完成售票，余票为 ：25
bb完成售票，余票为 ：24
bb完成售票，余票为 ：23
aa完成售票，余票为 ：22
aa完成售票，余票为 ：21
aa完成售票，余票为 ：20
aa完成售票，余票为 ：19
aa完成售票，余票为 ：18
aa完成售票，余票为 ：17
aa完成售票，余票为 ：16
aa完成售票，余票为 ：15
aa完成售票，余票为 ：14
aa完成售票，余票为 ：13
aa完成售票，余票为 ：12
aa完成售票，余票为 ：11
aa完成售票，余票为 ：10
aa完成售票，余票为 ：9
aa完成售票，余票为 ：8
aa完成售票，余票为 ：7
aa完成售票，余票为 ：6
aa完成售票，余票为 ：5
aa完成售票，余票为 ：4
bb完成售票，余票为 ：3
bb完成售票，余票为 ：2
bb完成售票，余票为 ：1
bb完成售票，余票为 ：0

4.读写分离锁：ReentrantReadWriteLock（读读共享、写写互斥、读写互斥）

public class UseReentrantReadWriteLock {

	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
	private ReadLock readLock = rwLock.readLock();
	private WriteLock writeLock = rwLock.writeLock();
	
	public void read(){
		try {
			readLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}
	
	public void write(){
		try {
			writeLock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.read();
			}
		}, "t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				urrw.write();
			}
		}, "t4");		
		
//		t1.start();
//		t2.start();
		
//		t1.start(); // R 
//		t3.start(); // W
		
		t3.start();
		t4.start();
	}
}

线程的死锁 ： 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

匿名内部类写一个死锁

public class TestThreadDeadLock {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//锁1 内部类如果引用外部类的变,则该变量必须为final,这是规定
		final Object obj1 = new Object();
		//锁2
		final Object obj2 = new Object();

		//线程1
		new Thread(){
			public void run(){
				synchronized (obj1) {
					System.out.println("获取资源1，等待资源2......");
					try {
						//线程1获取锁1后 睡一会（此时线程1占用锁1），等待线程2获取锁2（线程2占用锁2）
						Thread.sleep(200);
					} catch (InterruptedException e) {
					}
					synchronized (obj2) {
						System.out.println("--------------------------------");
					}
				}
			}
		}.start();

//		Thread.sleep(5000);

		//线程2
		new Thread() {
			public void run() {
				synchronized (obj2) {
					System.out.println("获取资源2，等待资源1......");
					synchronized (obj1) {
						System.out.println("****************************************");
					}
				}
			}
		}.start();
	}
}
获取资源1，等待资源2......
获取资源2，等待资源1......

代码写一个死锁

public class MyRunnable implements Runnable {

	//锁1  必须是static修饰的  代表同一把锁
	public static Object obj1 = new Object();

	//锁2
	public static Object obj2 = new Object();

	public boolean flag = true;

	@Override
	public void run() {
		if(flag){
			synchronized (obj1) {
				System.out.println("获取资源1，等待资源2......");
				try {
					Thread.sleep(200);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (obj2) {
					System.out.println("--------------------------");
				}
			}
		}else{
			synchronized (obj2) {
				System.out.println("获取资源2，等待资源1......");
				synchronized (obj1) {
					System.out.println("**************************");
				}
			}
		}
	}
}
public class TestThreadDeadLock {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		MyRunnable myRunnable1 = new MyRunnable();
		Thread thread1 = new Thread(myRunnable1);
		thread1.start();

		MyRunnable myRunnable2 = new MyRunnable();
		myRunnable2.flag = false;
		Thread thread2 = new Thread(myRunnable2);
		thread2.start();
	}
}
获取资源1，等待资源2......
获取资源2，等待资源1......
wxd_1024
关注
专栏目录
使用Windbg分析多线程临界区死锁问题分享
dvlinker的技术专栏
01-03 4万+
使用Windbg分析多线程临界区死锁问题分享。
Java多线程-线程安全问题练习题
01-30
线程安全问题通常出现在多线程环境下，当多个线程同时访问和修改共享资源时，可能导致数据不一致、死锁或竞态条件等问题。为解决这些问题，Java提供了多种机制： 1. **同步机制**：包括`synchronized`关键字和`Lock...
线程锁与避免线程锁 线程锁检测
weixin_34310369的博客
12-12 116
进程是资源共享的，线程是资源私有的。 死锁的四个必要条件在计算机专业的本科教材中，通常都会介绍死锁的四个必要条件。这四个条件缺一不可，或者说只要破坏了其中任何一个条件，死锁就不可能发生。我们来复习一下，这四个条件是：•互斥（Mutual exclusion）：存在这样一种资源，它在某个时刻只能被分配给一个执行绪（也称为线程）使用；•持有（Hold and wait）：当请求的资源已被占用从而导致...
Java基础-线程操作共享数据的安全问题
weixin_33811961的博客
05-07 135
　　　　　　　　　　　　　　　　　　　　Java基础-线程操作共享数据的安全问题 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰 版权声明：原创作品，谢绝转载！否则将追究法律责任。         一.引发线程安全问题 　　如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期...
JAVA：多线程与数据安全
最新发布
2401_87298532的博客
09-22 929
一、进程概论​ 进程就是指正在运行的程序的实例。当我们打开任务管理器的时候，在进程这一栏我们可以看到当前运行的所有进程,这些被我们称为进程。并且进程是系统进行资源分配和调用的独立单位，在任务管理器中我们可以看到每一个进程都有它自己的CPU占用程度、内存使用成都和对磁盘、网络的使用程度。二、线程概论而线程则是进程中的单个顺序的控制六，是一条执行路径。线程又可以分为和**单线程：**一个进程如果只有一个执行路径，则成为单线程程序**多线程：**一个进程如果有多个执行路径，那么成为多线程程序。
共享数据窗口问题
MakeToday的专栏
02-09 1221
pb 共享数据窗口问题1.主数据窗口为grid型，从数据窗口为free型。主数据窗口是为了浏览数据时使用的，单击每一条数据，从数据窗口中显示具体内容供浏览和修改，但是删除数据时，如果删除的是第一条数据，从数据窗口显示为空白，单击主窗口，也切换不过来 删除数据时。原因可能是scrolltorow(1)是在free窗口中无效应使用scrollfirstpage()替换.
线程共享数据的安全问题
weixin_30319097的博客
08-27 145
加同步代码：加了同步代码后，线程进同步判断锁，获取锁，出同步释放锁，保证了线程安全，但导致了线程运行速度的下降 方式一：同步代码块 　　解决线程安全问题，java程序提供了线程同步技术 　　synchronized(任意对象){ 　　　　线程要操作的共享数据 　　} 任意对象：通俗来讲叫同步锁或者对象监视器 同步的作用：保证线程的安全性，没有锁的线程是不能执行的，只能等待带锁的线...
Java——线程间的通信及共享数据的安全问题
凌风暨
10-10 345
//线程间的通信：线程的任务不同，但是线程操作的数据相同//描述数据 class Res{ String name; String sex; } //利用构造函数，把同一个res传给输入任务和输出任务 //即保证了两者为同一个res //描述输入任务 class Input implements Runnable{ private Res res; //两个线程同一把
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
典型死锁问题.rar_操作系统典型死锁问题
09-23
这是一个关于线程同步的经典问题，描述了两个线程（消费者和生产者）共享一个有限大小的缓冲区。生产者生产数据并放入缓冲区，消费者从缓冲区取出数据。如果没有适当的同步机制，可能会出现生产者填满缓冲区而消费者...
QT中sqlite多线程操作4个注意问题
02-26
然而，当在多线程环境中使用SQLite时，需要注意一些关键问题以确保数据的安全性和一致性。以下是四个重要的考虑因素： 1. **线程安全**： SQLite本身并不提供完全的线程安全，这意味着在不同线程中并发访问数据库...
【C++11多线程】线程锁保护共享数据
cutemypig的博客
12-23 1382
索引目录
共享内存在什么情况下会出现死锁
weixin_35750953的博客
02-15 365
共享内存是多进程或多线程共享同一块内存空间的机制。在多个进程或线程同时访问共享内存时，可能会出现死锁的情况。 死锁指的是多个进程或线程因为互相等待对方释放资源而陷入一种僵局的状态。在共享内存的情况下，死锁通常发生在以下情况： 竞争资源：多个进程或线程同时访问同一个共享资源，并试图获取对方持有的资源，导致互相等待。 无限等待：多个进程或线程在等待对方释放资源的过程中，可能会因为没有设置超时等待时...
JAVA之多线程的安全问题（线程同步）
一只攻城的柿子
07-05 928
一：使用多线程的优点：       提高应用程序的响应，对于图形化界面更有意义，增加用户体验。       提高CPU利用率       改善 程序结构，将长又复杂的进程分为多个线程，独立运行。 二 .线程安全问题：         由于一个线程在操作共享数据的过程中，没有执行完毕的情况下，另外的线程参与进来，导致共享数据存在安全问题。 三 .解决办法：             
多线程同步以及线程的锁机制，避免死锁等问题
大预言家
05-30 2432
话外语：我胡汉三又回来啦！！！----------------------------------------------------------------------------------------------------------------------------------Java中线程同步有一个典型的问题就是“生产者消费者”问题。用两个线程模拟存票售票过程：假定开始售票处并没有票...
正确使用锁保护共享数据，协调异步线程
JavaEdge全是干货的技术号
08-09 1797
JMQ为了提升整个流程的处理性能，使用了一个“近乎无锁”的设计，这里面其实隐含着两个信息点。第一个是，在消息队列中，“锁”是一个必须要使用的技术。第二个是，使用锁其实会降低系统的性能。 那么，如何正确使用锁，又需要注意哪些事项呢？今天我们就来聊一聊这个问题。 我们知道，使用异步和并发的设计可以大幅提升程序的性能，但我们为此付出的代价是，程序比原来更加复杂了，多线程在并行执行的时候，带来了很多不确定性。特别是对于一些需要多个线程并发读写的共享数据，如果处理不好，很可能会产出不可预期的结果，这肯定不是我们想要的
多线程和多进程中避免锁机制注意的几点
weixin_30657541的博客
11-02 180
　　通常在涉及到多线程和多进程操作共享数据时候，不可避免的会涉及到公共数据的互斥访问，可能会用到互斥锁，事件，信号量等，然而在使用这些锁机制的同时肯定会降低系统的并发性，同时如果使用不当可能还会造成一些死锁等很让人反感的问题。 其实大部分时候可以通过一些细节的设计来避免锁机制，共享数据的互斥访问总的来说可以分为以下两种： 1、同时修改 先来个例子说明下同时修改数据造成数据不一致的问题： 假...
Java线程并发中的锁——Lock(上)
路漫漫，水迢迢
05-19 2051
Lock接口锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发的访问共享资源，比如读写锁）。在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的，而Java SE 5之后，并发包中新增了Lock接口（以及相关实现类）用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需
清华大学操作系统OS学习（十三）——死锁、进程通信、信号、管道、消息队列和共享内存
一路嵌行的博客
06-19 379
一、死锁概念 ①死锁：一组阻塞的进程（两个或多个），持有一种资源，等待获取另一个进程所占有的资源，而导致谁都无法执行。 ②可重复使用的资源： 在一个时间只能一个进程使用，且不能被删除。OS避免杀死拥有资源的进程；进程使用资源后要释放，让其他进程重用；有物理资源（cpu， I/O通道，主和副存储器），也有抽象的资源（设备和数据结构，如文件，数据库和信号量）；如果每个进程拥有一个资源并请求其他...
线程基础：安全问题、死锁与通信详解
3. 线程安全问题，如果不恰当使用共享数据，可能会引发数据竞争，导致程序行为不可预测。 接下来，文章介绍了如何创建线程，通过继承Thread类的方式实现。例如，我们看到一个名为`BuildThread01`的示例，它重写了`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值