Java 读书笔记 21.2 并发

并发

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 EvenChecker implements Runnable {    private IntGenerator generator;    private final int id;    public EvenChecker(IntGenerator g, int ident) {        generator = g;        id = ident;    }    public void run() {        while(!generator.isCanceled()) {            int val = generator.next();            //System.out.println(val);            if(val % 2 != 0) {                System.out.println(val + " not even!");                generator.cancel(); // Cancels all EvenCheckers            }        }    }    // Test any type of IntGenerator:    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();    }    // Default value for count:    public static void test(IntGenerator gp) {        test(gp, 10);    }} 

public class EvenGenerator extends IntGenerator {    private int currentEvenValue = 0;    public  synchronized  int next() {        ++currentEvenValue;    //简单地说synchronized关键字将next（）锁了起来，                              //加两次的中间是不会被的线程抢走；        Thread.yield();        ++currentEvenValue;        return currentEvenValue;    }    public static void main(String[] args) {        EvenChecker.test(new EvenGenerator());    }}

或者通过显式的lock关键字

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

你可能发现lock要写好多东西，这也是java的思想，宁愿写的多，也舒服，非常明显的锁和释放，而且更细

import java.util.concurrent.*;  import java.util.concurrent.locks.*;  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();      }    }    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) {      final AttemptLocking al = new AttemptLocking();      al.untimed(); // True -- lock is available      al.timed();   // True -- lock is available      // Now create a separate task to grab the lock:      new Thread() {        { setDaemon(true); }        public void run() {          al.lock.lock();          System.out.println("acquired");        }      }.start();      Thread.yield(); // Give the 2nd task a chance      al.untimed(); // False -- lock grabbed by task      al.timed();   // False -- lock grabbed by task    }  

当线程被锁起来，下面两个函数虽然拿不到锁，但是还可以做别的；

原子性