《Java并发编程实战》读书笔记

package my.concurrent.semaphore;

import java.util.concurrent.Semaphore;

public class Car implements Runnable {

     private final Semaphore parkingSlot;

     private int carNo;

     /**
     * @param parkingSlot
     * @param carName
     */
     public Car(Semaphore parkingSlot, int carNo) {
          this.parkingSlot = parkingSlot;
          this.carNo = carNo;
     }

     public void run() {

          try {
               parkingSlot.acquire();
               parking();
               sleep(300);
               parkingSlot.release();
               leaving();

          } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
          }

     }

     private void parking() {
          System.out.println(String.format("%d号车泊车", carNo));
     }

     private void leaving() {
          System.out.println(String.format("%d号车离开车位", carNo));
     }

     private static void sleep(long millis) {
          try {
               Thread.sleep(millis);
          } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();

          }
     }

}

package my.concurrent.semaphore;

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

public class ParkingCars {

     private static final int NUMBER_OF_CARS = 30;

     private static final int NUMBER_OF_PARKING_SLOT = 10;

     public static void main(String[] args) {

          /*
          * 采用FIFO, 设置true
          */
          Semaphore parkingSlot = new Semaphore(NUMBER_OF_PARKING_SLOT, true);

          ExecutorService service = Executors.newCachedThreadPool();

          for (int carNo = 1; carNo <= NUMBER_OF_CARS; carNo++) {
               service.execute(new Car(parkingSlot, carNo));
          }

          sleep(3000);

          service.shutdown();

          /*
          * 输出还有几个可以用的资源数
          */
          System.out.println(parkingSlot.availablePermits() + " 个停车位可以用!");
     }

     private static void sleep(long millis) {
          try {
               Thread.sleep(millis);
          } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
          }
     }

}

class singleThreadWebServer {
      ServerSocket socket = new ServerSocket(80) ;
      while (true) {
             Socket connection = socket.accept();
            handleRequest(connection);
      }
}

class MultiThreadWebServer {
      ServerSocket socket = new ServerSocket(80) ;
      while (true) {
             final Socket connection = socket.accept();
            Runnable task = new Runnable() {
                   public void run() {
                        handleRequest(connection);
                  }
             }
             new Thread(task).start();
      }
}

2、Executor 框架

先给一张java.util.concurrent 的结构

任务是一组逻辑工作单元，而线程则是使任务异步执行的逻辑单元。Executor为灵活且强大的异步任务执行框架提供了基础，还提供了对生命周期的支持，以及统计信息、应用管理机制和性能监视等机制。
Executor 基于生产者-消费者模式。提交任务相当是生产者，执行任务相当是消费者

a、执行策略：
任务在什么（What）线程中执行
任务以什么（What）顺序执行（FIFO/LIFO/优先级等）
同时有多少个（How Many）任务并发执行
允许有多少个（How Many）个任务进入执行队列
系统过载时选择放弃哪一个（Which）任务，如何（How）通知应用程序这个动作
任务执行的开始、结束应该做什么（What）处理

b、线程池：
线程池和工作者队列密切相关，工作者线程的任务：从工作队列中获取一个任务，执行任务，然后返回线程池并等待下一个任务。
Executors类里面提供了一些静态工厂，生成一些常用的线程池。
newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
newSingleThreadScheduledExecutor：创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

c、线程池Executor任务拒绝策略
java.util.concurrent.RejectedExecutionHandler描述的任务操作。
第一种方式直接丢弃（DiscardPolicy）
第二种丢弃最旧任务（DiscardOldestPolicy）
第三种直接抛出异常（AbortPolicy）
第四种任务将有调用者线程去执行(CallerRunsPolicy)

d、生命周期
java.util.concurrent.ExecutorService 接口对象来执行任务，该接口对象通过工具类java.util.concurrent.Executors的静态方法来创建。 Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。
ExecutorService扩展了Executor并添加了一些生命周期管理的方法。一个Executor的生命周期有三种状态，运行 ，关闭 ，终止。Executor创建时处于运行状态。当调用ExecutorService.shutdown()后，处于关闭状态，isShutdown()方法返回true。这时，不应该再想Executor中添加任务，所有已添加的任务执行完毕后，Executor处于终止状态，isTerminated()返回true。
shutdown()：执行平缓的关闭过程，不再接受新的任务，同时等待已经提交的任务执行完成。
shutdownNow();执行粗暴的关闭过程，尝试取消所有运行中的任务，并且不再启动队列中尚未开始启动的任务。
awaitTermination： 这个方法有两个参数，一个是timeout即超时时间，另一个是unit即时间单位。这个方法会使线程等待timeout时长，当超过timeout时间后，会监测ExecutorService是否已经关闭，若关闭则返回true，否则返回false。一般情况下会和shutdown方法组合使用。

 ExecutorService service = Executors. newFixedThreadPool(3);
          for ( int i = 0; i < 10; i++) {
              System. out.println( "创建线程" + i);
              Runnable run = new Runnable() {
                  @Override
                  public void run() {
                      System. out.println( "启动线程");
                  }
              };
              // 在未来某个时间执行给定的命令
              service.execute(run);
          }
          // 关闭启动线程
          service.shutdown();
          // 每隔1秒监测一次ExecutorService的关闭情况.
          service.awaitTermination(1, TimeUnit. SECONDS);
          System. out.println( "all thread complete");
          System. out.println(service.isTerminated());

public class CASCount implements Runnable {
	
	private SimilatedCAS counter = new SimilatedCAS();  

	@Override
	public void run() {
		 for (int i = 0; i < 10000; i++) {  
	            System.out.println(this.increment());  
	     }  
	}
	
	public int increment() {
		int oldValue = counter.getValue();
		int newValue = oldValue + 1;
		
		while (!counter.compareAndSwap(oldValue, newValue)) { //如果CAS失败,就去拿新值继续执行CAS
			  oldValue = counter.getValue();  
	          newValue = oldValue + 1;  
		}
		
		return newValue;
	}
	
	public static void main(String[] args) {  
        Runnable run = new CASCount();  
  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
    }  

}

class SimilatedCAS {
	private int value;
	
	public int getValue() {
		return value;
	}
	
	// 这里只能用synchronized了,毕竟无法调用操作系统的CAS  
    public synchronized boolean compareAndSwap(int expectedValue, int newValue) {  
        if (value == expectedValue) {  
            value = newValue;  
            return true;  
        }  
          
        return false;  
    }  
}

public class AtomicCounter implements Runnable{
	
	//AtomicInteger采用了系统的CAS
	private AtomicInteger value = new AtomicInteger();  

	@Override
	public void run() {
		for (int i = 0; i < 10000; i++) {  
            System.out.println(value.incrementAndGet());  
        }  
	}
	
	public static void main(String[] args) {  
        Runnable run = new AtomicCounter();  
  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
        new Thread(run).start();  
    }  

}

public class ConcurrentStack {
	
	class Node {
		public final int item;
		public Node next;
		public Node(int item) {
			this.item = item;
		}
	}
	
	private AtomicReference<Node> top = new AtomicReference<ConcurrentStack.Node>();
	
	//入栈
	public void push(int item) {
		Node newNode = new Node(item);
		Node oldHead;
		do {
			oldHead = top.get();
			newNode.next = oldHead;
		} while (!top.compareAndSet(oldHead, newNode));
	}
	
	//出栈
	public int pop() {
		Node oldHead;
		Node newHead;
		do {
			oldHead = top.get();
			if(oldHead == null ) {
				return -1;
			}
			newHead = oldHead.next; 
			//Atomically sets the value to the given updated value if the current value {@code ==} the expected value.
		} while (!top.compareAndSet(oldHead, newHead));
		return oldHead.item;
	}

}