java 资源竞争_Java-如何避免资源竞争问题

生产者和消费者在同一时间段内共用同一个存储空间，生产者向空间里存放数据，而消费者取用数据，如果不加以协存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁

解决流程：对独占空间加锁，阻塞和唤醒线程。

下面是通过await()和signal()，即线程锁的方式来解决的

package com.ch.egg;

import java.util.LinkedList;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

* ReentrantLock 是一个可重入的互斥锁 Lock，

* 它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大

*

* Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象，

* 以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set(wait-set)。

* 其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

*

* @author ch

*

*/

public class ThreadEggLock {

private LinkedList eggs = new LinkedList();

private int MAX = 1;

private final Lock lock = new ReentrantLock();

private final Condition full = lock.newCondition();

private final Condition empty = lock.newCondition();

private int count = 0;

public void start() {

new Producer().start();

new Consumer().start();

}

public static void main(String[] args) throws Exception {

ThreadEggLock s2 = new ThreadEggLock();

s2.start();

}

class Producer extends Thread {

public void run() {

while (count < 5) {

lock.lock();

try {

while (eggs.size() == MAX) { //盘子里满了

System.out.println("------警告：盘子里满了!");

full.await();

}

Object egg = new Object();

if (eggs.add(egg)) {

System.out.println("放入 鸡蛋" + count);

empty.signal();

}

} catch (InterruptedException ie) {

System.out.println("producer is interrupted!");

} finally {

lock.unlock();

}

}

}

}

class Consumer extends Thread {

public void run() {

while (count <= 5) {

lock.lock();

try {

while (eggs.size() == 0) { //盘子是空的

System.out.println("------警告：现在盘子是空的");

empty.await();

}

eggs.removeLast();

System.out.println("拿走 鸡蛋" + count);

count++;

full.signal();

} catch (InterruptedException ie) {

System.out.println("consumer is interrupted!");

} finally {

lock.unlock();

}

}

}

}

}

顺便总结一下线程同步：

1、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。

2、线程同步方法是通过锁来实现，每个对象都有且仅有一个锁，这个锁与一个特定的对象关联；线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。

3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

4、对于同步，要时刻明白是在哪个对象上同步。

5、在使用synchronized关键字时候，应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法，因为synchronized程序块占有着对象锁，你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率，也不合逻辑。同样，在同步程序块内调用yeild方法让出CPU资源也没有意义，因为你占用着锁，其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。

6、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

7、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

8、死锁是线程间相互等待锁锁造成的，一旦程序发生死锁，程序将死掉。