线程中的冲突问题

本文探讨了Java多线程环境下的冲突问题,通过实例展示了在多个线程同时操作同一数据时可能出现的问题,并介绍了如何使用`synchronized`关键字解决此类冲突。详细解释了`synchronized`的作用以及它如何确保同一时间只有一个线程执行特定代码段,从而避免数据不一致的情况。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

我们知道,对于一个Thread的对象t,当调用start方法后,该线程就会一直执行。

那么什么是线程中的冲突问题呢?如果现在有两个线程t1、t2,并且这两个线程中的run方法同时操作同一数据,就比如说,有一个定义好的整型变量c,并且附上初始值10,然后在run方法中使c不断进行自减操作,并且通过while(c > 0)操控线程的生命。


public class ThreadTest extends Thread {

	int c = 10;
	
	public ThreadTest() {
		
		Thread t1 = new Thread(this);
		Thread t2 = new Thread(this);
		t1.start();
		t2.start();
	}
	
	public void run() {
		while(c> 0) {
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			c--;
			System.out.println("c = " + c);;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			new ThreadTest();
	}
}


在上述代码中,我们可以看到在t1和t2的run方法中同时对c进行了自减操作,然后我们运行,发现运行结果如下:

c = 9
c = 8
c = 7
c = 6
c = 5
c = 4
c = 3
c = 2
c = 1
c = 0
c = -1

看到,在最后出现了一个-1,明明当c自减到0的时候线程就已经消亡了,为什么还会出现c继续自减变成-1呢?这就是线程中的冲突问题,我们来分析一下,为什么会出现-1,我们在上述代码中设置了线程休眠50ms,那么比如说现在程序运行到了t1这个线程中c1自减变成了0,那么此时此刻,c是等于0了对吧?但是呢?在t1中c还未自减之前还是为1,但是此时在t2中while(c>0)已经成功判断了,那么在t1中c自减之后,又在t2中c自减,此时,出现了-1这种情况。

那么,这显然不符合我们想要的结果,对于这样的问题,我们可以通过一个标识synchronized来解决这类问题,具体怎么用如下:

public void run() {
		synchronized (this) {
			while(c> 0) {
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				c--;
				System.out.println("c = " + c);;
			}
		}
	}

那么什么是synchronized标识呢?synchronized标识的是一代码段或者方法,即为“对象互斥锁”锁住的部分,那到底通过这个标识是怎么使得上述代码不再出现-1呢?其实是这样,上述代码中t1和t2两个线程启动后不断run,那么通过这个标识后,就会使得同一时间只能由一个线程来执行该代码段或者方法,通过如此,就能解决线程中的冲突问题了。

### 线程冲突的原因 线程冲突通常发生在多个线程试图同时访问同一资源的情况下,而这些操作可能会破坏数据的一致性和完整性。具体来说,线程冲突的主要原因可以归纳为以下几个方面: 1. **共享可变状态** 当多个线程尝试修改同一个共享变量或对象的状态时,如果没有适当的保护措施,则可能导致不一致的结果[^2]。 2. **缺乏同步控制** 如果程序中的某些关键部分未被正确加锁或者没有使用其他形式的同步机制来协调线程间的执行顺序,就可能引发竞争条件(Race Condition)。这种情况下,最终结果取决于哪个线程先完成了特定的操作[^4]。 3. **死锁风险** 死锁是一种特殊类型的线程冲突,发生在一个线程持有某个资源并请求另一个资源的同时,另一线程也持有所需的不同资源却反过来请求前者所拥有的资源。这种情况会阻止两个线程继续运行下去直到它们释放各自的锁定资源[^1]。 --- ### 解决方案 针对上述提到的各种潜在问题,有多种技术和模式可以帮助开发者设计更加健壮的应用程序以应对复杂的并发场景: #### 使用内置锁机制 Java 提供了 `synchronized` 关键字作为最基础也是最常见的手段之一用于实现互斥访问临界区代码段的功能。例如下面展示了一个简单的银行账户转账案例说明如何利用该特性防止余额更新过程中可能出现的数据丢失现象: ```java public class BankAccount { private double balance; public synchronized void deposit(double amount){ this.balance += amount; } public synchronized void withdraw(double amount)throws Exception{ if (this.balance >= amount) { this.balance -= amount; }else throw new Exception("Insufficient funds"); } } ``` 这里通过声明方法级别上的同步属性确保任何时候只有一个线程能进入相应的方法体内部从而避免了因交替读写造成的错误计算结果。 #### 显式锁管理 除了依靠 JVM 自动处理外还可以借助更灵活可控的方式比如 ReentrantLock 类来自定义细粒度更高的锁定策略以便于满足实际需求下的性能优化目标等等: ```java import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class CounterWithExplicitLock { private int count = 0; private final Lock lock = new ReentrantLock(); public void increment(){ lock.lock(); // acquire the lock before modifying shared state. try { count++; }finally { lock.unlock();// ensure that we release it even upon exception occurrence. } } public int getCount(){return count;} } ``` 另外还有诸如信号量(Semaphore), 计数器(CountDownLatch) 和交换机(CyclicBarrier) 这些高级工具也可以用来构建更为复杂的行为逻辑模型[^3]. #### 不可变对象原则 创建不可改变的对象意味着一旦实例化之后其成员字段就不能再发生变化因此天然具备线程安全性无需额外考虑防护措施即可放心大胆地跨不同上下文中重复利用. 最后值得注意的是尽管采取以上任何单项技术都能够有效缓解一部分挑战但仍建议综合运用各种最佳实践共同作用才能最大程度提升系统的稳定可靠程度. ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值