Java并发：临界资源，线程同步

public abstract class IntGenerator {
 private volatile boolean canceled = false;

 public abstract int next();

 // Allow this to be canceled;
 public void cancel() {
	 canceled = true;
 }

 public boolean isCanceled() {
	 return canceled;
 }
}

 public class EvenGenerator extends IntGenerator {
  
  private int currentEvenValue = 0;
 
  @Override
  public int next() {
	  ++currentEvenValue; //Danger point here!
	  ++currentEvenValue;
	  return currentEvenValue;
  }
  
  public static void main(String[] args) {
	  EvenChecker.test(new EvenGenerator());
  }
 
 }

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class EvenChecker implements Runnable {
 private IntGenerator generator;
 private final int id;
 public EvenChecker(IntGenerator g, int ident) {
	 generator = g;
	 this.id = ident;
 }
 
 @Override
 public void run() {
	 while(!generator.isCanceled()) {
		 int val = generator.next();
		 if(val % 2 != 0) {
			 System.out.println(val + " not even!");
			 generator.cancel(); // Cancels all EvenCheckers
		 }
	 }
 }
 
 public static void test(IntGenerator gp, int count) {
	 System.out.println("Press Control-C to exit!");
	 ExecutorService exec = Executors.newCachedThreadPool();
	 for(int i = 0; i < count; i++) {
		 exec.execute(new EvenChecker(gp, i));
	 }
	 exec.shutdown();
 }
 
 public static void test(IntGenerator gp) {
	 test(gp, 10);
 }
}

public class EvenGenerator extends IntGenerator {
 
 private int currentEvenValue = 0;

 @Override
 public synchronized int next() {
	 ++currentEvenValue; //Danger point here!
	 ++currentEvenValue;
	 return currentEvenValue;
 }
 
 public static void main(String[] args) {
	 EvenChecker.test(new EvenGenerator());
 }

}

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

public class MutexEvenGenerator extends IntGenerator {
 private int currentValue = 0;
 private Lock lock = new ReentrantLock();
 
 public int next() {
	 lock.lock();
	 try {
		 ++currentValue;
		 Thread.yield();
		 ++currentValue;
		 return currentValue;
	 } finally {
		 lock.unlock();
	 }
 }
 
 public static void main(String[] args) {
	 EvenChecker.test(new MutexEvenGenerator());
 }
}

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

public class AttemptLocking {
 private ReentrantLock lock = new ReentrantLock();

 // 直接去获取锁，然后输出状态。
 public void untimed() {
	 boolean captured = lock.tryLock();
	 try {
		 System.out.println("tryLock(): " + captured);
	 } finally {
		 if (captured) {
			 lock.unlock();
		 }
	 }
 }

 //尝试获取2s，如果失败就返回。
 public void timed() {
	 boolean captured = false;
	 try {
		 captured = lock.tryLock(2, TimeUnit.SECONDS);
	 } catch (InterruptedException e) {
		 throw new RuntimeException(e);
	 }

	 try {
		 System.out.println("tryLock(2, TimeUnit.SECONDS): " + captured);
	 } finally {
		 if (captured) {
			 lock.unlock();
		 }
	 }
 }

 public static void main(String[] args) throws InterruptedException {
	 final AttemptLocking al = new AttemptLocking();
	 al.untimed();
	 al.timed();

	 new Thread() {
		 {
			 setDaemon(true);
		 }

		 public void run() {
			 al.lock.lock();
			 System.out.println("acquired");
		 }
	 }.start();
	 TimeUnit.MILLISECONDS.sleep(1000);
	 al.untimed();
	 al.timed();
 }

}/*output:
tryLock(): true
tryLock(2, TimeUnit.SECONDS): true
acquired
tryLock(): false
tryLock(2, TimeUnit.SECONDS): false
*/

while(true) {
  1. 首先使用boolean captured = lock.tryLock()，如果是 true 的话就走正常的逻辑
  2. 如果 false 的话，使用captured = lock.tryLock(2, TimeUnit.SECONDS)尝试获取锁，如果2秒内不断轮询并且获得了锁，就走正常的逻辑
  3. 如果超过2s还是不能获取，我就干点其他的事情。
}

synchronized(syncObject) {
  //This code can be accessd
  //by only one task at a time
}

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * 定义一个坐标，重点在于 x 和 y 都有自加1操作.如果 x != y，会抛出一个自定义的运行时异常
  * @author niushuai
  *
  */
 class Pair {
	 private int x, y;
 
	 public Pair(int x, int y) {
		 this.x = x;
		 this.y = y;
	 }
 
	 public Pair() {
		 this(0, 0);
	 }
 
	 public int getX() {
		 return x;
	 }
 
	 public int getY() {
		 return y;
	 }
 
	 public void incrementX() {
		 x++;
	 }
 
	 public void incrementY() {
		 y++;
	 }
 
	 public String toString() {
		 return "x: " + x + ", y: " + y;
	 }
 
	 /**
	 * 如果 x != y 则抛出异常
	 * @author niushuai
	 *
	 */
	 public class PairValuesNotEqualException extends RuntimeException {
		 /**
		 * 
		 */
		 private static final long serialVersionUID = -7103813289682393079L;
 
		 public PairValuesNotEqualException() {
			 super("Pair values not equal: " + Pair.this);
		 }
	 }
 
	 public void checkState() {
		 if (x != y) {
			 System.err.println("x != y");
			 throw new PairValuesNotEqualException();
		 }
	 }
 }
 
 /**
  * 对 Pair 进行管理的模板方法，如何对非线程安全的 Pair 进行自增？
  * 是同步整个方法？还是同步临界区？——子类实现
  */
 abstract class PairManager {
	 //check x != y 的次数
	 AtomicInteger checkCounter = new AtomicInteger(0);
	 protected Pair p = new Pair();
	 //synchronizedList 为线程安全，无论在同步块内还是同步块外都是线程安全的
	 private List<Pair> storage = Collections
			 .synchronizedList(new ArrayList<Pair>());
 
	 public synchronized Pair getPair() {
		 return new Pair(p.getX(), p.getY());
	 }
 
	 protected void store(Pair p) {
		 storage.add(p);
		 try {
			 TimeUnit.MILLISECONDS.sleep(50);
		 } catch (InterruptedException e) {
			 e.printStackTrace();
		 }
	 }
 
	 // 如何增长？synchronized 修饰方法 还是 synchronized 修饰临界区？
	 public abstract void increment();
 }
 
 /**
  * synchronized 修饰整个方法
  * @author niushuai
  *
  */
 class PairManager1 extends PairManager {
	 public synchronized void increment() {
		 p.incrementX();
		 p.incrementY();
		 store(getPair());
	 }
 }
 
 /**
  * synchronized 修饰临界区
  * @author niushuai
  *
  */
 class PairManager2 extends PairManager {
	 public void increment() {
		 Pair temp;
		 synchronized (this) {
			 p.incrementX();
			 p.incrementY();
			 temp = getPair();
		 }
		 store(temp);
	 }
 }
 
 /** 
  * 任务类1，可以使用不同的 PairManager 对 Pair 进行自增操作
  * @author niushuai
  *
  */
 class PairManipulator implements Runnable {
	 private PairManager pm;
 
	 public PairManipulator(PairManager pm) {
		 this.pm = pm;
	 }
 
	 @Override
	 public void run() {
		 while (true) {
			 pm.increment();
		 }
	 }
 
	 public String toString() {
		 return "Pair: " + pm.getPair() + " checkCounter = "
				 + pm.checkCounter.get();
	 }
 }
 
 /** 
  * 任务类2，不断的去检测 Pair 中的 x == y 状态
  * @author niushuai
  *
  */
 class PairChecker implements Runnable {
	 private PairManager pm;
 
	 public PairChecker(PairManager pm) {
		 this.pm = pm;
	 }
 
	 @Override
	 public void run() {
		 while (true) {
			 pm.checkCounter.incrementAndGet();
			 pm.getPair().checkState();
		 }
	 }
 }
 
 public class CriticalSection {
	 static void testApproaches(PairManager pman1, PairManager pman2) {
		 ExecutorService exec = Executors.newCachedThreadPool();
		 PairManipulator pm1 = new PairManipulator(pman1);
		 PairManipulator pm2 = new PairManipulator(pman2);
		 PairChecker pcheck1 = new PairChecker(pman1);
		 PairChecker pcheck2 = new PairChecker(pman2);
 
		 exec.execute(pm1);
		 exec.execute(pm2);
		 exec.execute(pcheck1);
		 exec.execute(pcheck2);
		 try {
			 TimeUnit.MILLISECONDS.sleep(500);
		 } catch (InterruptedException e) {
			 System.out.println("Sleep interrupted");
		 }
		 System.out.println("pm1: " + pm1 + "\npm2: " + pm2);
		 System.exit(0);
	 }
 
	 public static void main(String[] args) {
		 PairManager pman1 = new PairManager1();
		 PairManager pman2 = new PairManager2();
 
		 testApproaches(pman1, pman2);
	 }
 }/*output:
 pm1: Pair: x: 165, y: 165 checkCounter = 6
 pm2: Pair: x: 166, y: 166 checkCounter = 370681186
 */

class DualSynch {
 private Object syncObject = new Object();
 public synchronized void f() {
	 for(int i = 0; i < 5; i++) {
		 System.out.println("f()");
		 Thread.yield();
	 }
 }
 
 public void g() {
	 synchronized(syncObject) {
		 for(int i = 0; i < 5; i++) {
			 System.out.println("g()");
			 Thread.yield();
		 }
	 }
 }
}

public class SyncObject {
 public static void main(String[] args) {
	 final DualSynch ds = new DualSynch();
	 new Thread() {
		 public void run() {
			 ds.f();
		 }
	 }.start();
	 ds.g();
 }
}/*output:
f()
g()
f()
f()
g()
f()
g()
f()
g()
g()
*/