java concurrent详解 谈谈java的concurrent用法

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyExecutor extends Thread {
private int index;
public MyExecutor(int i){
  this.index=i;
}
public void run(){
  try{
   System.out.println("["+this.index+"] start....");
   Thread.sleep((int)(Math.random()*));
   System.out.println("["+this.index+"] end.");
  }
  catch(Exception e){
   e.printStackTrace();
  }
}
public static void main(String args[]){
  ExecutorService service=Executors.newFixedThreadPool();
  for(int i=;i<;i++){
   service.execute(new MyExecutor(i));
   //service.submit(new MyExecutor(i));
  }
  System.out.println("submit finish");
  service.shutdown();
}
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class MySemaphore extends Thread {
Semaphore position;
private int id;
public MySemaphore(int i,Semaphore s){
  this.id=i;
  this.position=s;
}
public void run(){
  try{
   if(position.availablePermits()>){
   System.out.println("顾客["+this.id+"]进入厕所，有空位");
   }
   else{
   System.out.println("顾客["+this.id+"]进入厕所，没空位，排队");
   }
   position.acquire();
   System.out.println("顾客["+this.id+"]获得坑位");
   Thread.sleep((int)(Math.random()*));
   System.out.println("顾客["+this.id+"]使用完毕");
   position.release();
  }
  catch(Exception e){
   e.printStackTrace();
  }
}
public static void main(String args[]){
  ExecutorService list=Executors.newCachedThreadPool();
  Semaphore position=new Semaphore();
  for(int i=;i<;i++){
   list.submit(new MySemaphore(i+,position));
  }
  list.shutdown();
  position.acquireUninterruptibly();
  System.out.println("使用完毕，需要清扫了");
  position.release();
}
}

class X {
  private final ReentrantLock lock = new ReentrantLock();
  // ...
  public void m() {
   lock.lock(); // block until condition holds
   try {
    // ... method body
   } finally {
    lock.unlock()
   }
  }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
public class MyReentrantLock extends Thread{
TestReentrantLock lock;
private int id;
public MyReentrantLock(int i,TestReentrantLock test){
  this.id=i;
  this.lock=test;
}
public void run(){
  lock.print(id);
}
public static void main(String args[]){
  ExecutorService service=Executors.newCachedThreadPool();
  TestReentrantLock lock=new TestReentrantLock();
  for(int i=;i<;i++){
   service.submit(new MyReentrantLock(i,lock));
  }
  service.shutdown();
}
}
class TestReentrantLock{
private ReentrantLock lock=new ReentrantLock();
public void print(int str){
  try{
   lock.lock();
   System.out.println(str+"获得");
   Thread.sleep((int)(Math.random()*));
  }
  catch(Exception e){
   e.printStackTrace();
  }
  finally{
   System.out.println(str+"释放");
   lock.unlock();
  }
}
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
public class MyBlockingQueue extends Thread {
public static BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
private int index;
public MyBlockingQueue(int i) {
  this.index = i;
}
public void run() {
  try {
  queue.put(String.valueOf(this.index));
  System.out.println("{" + this.index + "} in queue!");
  } catch (Exception e) {
  e.printStackTrace();
  }
}
public static void main(String args[]) {
  ExecutorService service = Executors.newCachedThreadPool();
  for (int i = ; i < ; i++) {
  service.submit(new MyBlockingQueue(i));
  }
  Thread thread = new Thread() {
  public void run() {
   try {
   while (true) {
    Thread.sleep((int) (Math.random() * ));
    if(MyBlockingQueue.queue.isEmpty())
    break;
    String str = MyBlockingQueue.queue.take();
    System.out.println(str + " has take!");
   }
   } catch (Exception e) {
   e.printStackTrace();
   }
  }
  };
  service.submit(thread);
  service.shutdown();
}
}

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class MyCompletionService implements Callable<String> {
private int id;
public MyCompletionService(int i){
  this.id=i;
}
public static void main(String[] args) throws Exception{
  ExecutorService service=Executors.newCachedThreadPool();
  CompletionService<String> completion=new ExecutorCompletionService<String>(service);
  for(int i=;i<;i++){
  completion.submit(new MyCompletionService(i));
  }
  for(int i=;i<;i++){
  System.out.println(completion.take().get());
  }
  service.shutdown();
}
public String call() throws Exception {
  Integer time=(int)(Math.random()*);
  try{
  System.out.println(this.id+" start");
  Thread.sleep(time);
  System.out.println(this.id+" end");
  }
  catch(Exception e){
  e.printStackTrace();
  }
  return this.id+":"+time;
}
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException {
  // 开始的倒数锁
  final CountDownLatch begin = new CountDownLatch();
  // 结束的倒数锁
  final CountDownLatch end = new CountDownLatch();
  // 十名选手
  final ExecutorService exec = Executors.newFixedThreadPool();
  for (int index = ; index < ; index++) {
  final int NO = index + ;
  Runnable run = new Runnable() {
   public void run() {
   try {
    begin.await();//一直阻塞
    Thread.sleep((long) (Math.random() * ));
    System.out.println("No." + NO + " arrived");
   } catch (InterruptedException e) {
   } finally {
    end.countDown();
   }
   }
  };
  exec.submit(run);
  }
  System.out.println("Game Start");
  begin.countDown();
  end.await();
  System.out.println("Game Over");
  exec.shutdown();
}
}

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCyclicBarrier {
 // 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan
 private static int[] timeWalk = { , , , , };
 // 自驾游
 private static int[] timeSelf = { , , , , };
 // 旅游大巴
 private static int[] timeBus = { , , , , };
 static String now() {
   SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
   return sdf.format(new Date()) + ": ";
 }
 static class Tour implements Runnable {
   private int[] times;
   private CyclicBarrier barrier;
   private String tourName;
   public Tour(CyclicBarrier barrier, String tourName, int[] times) {
    this.times = times;
    this.tourName = tourName;
    this.barrier = barrier;
   }
   public void run() {
    try {
     Thread.sleep(times[] * );
     System.out.println(now() + tourName + " Reached Shenzhen");
     barrier.await();
     Thread.sleep(times[] * );
     System.out.println(now() + tourName + " Reached Guangzhou");
     barrier.await();
     Thread.sleep(times[] * );
     System.out.println(now() + tourName + " Reached Shaoguan");
     barrier.await();
     Thread.sleep(times[] * );
     System.out.println(now() + tourName + " Reached Changsha");
     barrier.await();
     Thread.sleep(times[] * );
     System.out.println(now() + tourName + " Reached Wuhan");
     barrier.await();
    } catch (InterruptedException e) {
    } catch (BrokenBarrierException e) {
    }
   }
 }
 public static void main(String[] args) {
   // 三个旅行团
   CyclicBarrier barrier = new CyclicBarrier();
   ExecutorService exec = Executors.newFixedThreadPool();
   exec.submit(new Tour(barrier, "WalkTour", timeWalk));
   exec.submit(new Tour(barrier, "SelfTour", timeSelf));
//当我们把下面的这段代码注释后，会发现，程序阻塞了，无法继续运行下去。
   exec.submit(new Tour(barrier, "BusTour", timeBus));
   exec.shutdown();
 }
}

import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
public class TestScheduledThread {
public static void main(String[] args) {
  final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool();
  final Runnable beeper = new Runnable() {
  int count = ;
  public void run() {
   System.out.println(new Date() + " beep " + (++count));
  }
  };
  // 秒钟后运行，并每隔秒运行一次
  final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(beeper, , , SECONDS);
  // 秒钟后运行，并每次在上次任务运行完后等待秒后重新运行
  final ScheduledFuture beeperHandle = scheduler.scheduleWithFixedDelay(beeper, , , SECONDS);
  // 秒后结束关闭任务，并且关闭Scheduler
  scheduler.schedule(new Runnable() {
  public void run() {
   beeperHandle.cancel(true);
   beeperHandle.cancel(true);
   scheduler.shutdown();
  }
  }, , SECONDS);
}
}