三、JUC系列之---Concurrent

1、卖票

需求：三我的卖30张票

代码：

package com.lee.juc.concurrent;

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

public class SaleTicket {

	public static void main(String[] args) {
		
		Ticket ticket = new Ticket();
		
		new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<100;i++) {
					ticket.sale();
				}
			}
		},"AA").start();
		
		new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<100;i++) {
					ticket.sale();
				}
			}
		},"BB").start();
		
		new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<100;i++) {
					ticket.sale();
				}
			}
		},"CC").start();
		
	}
}

//票
class Ticket{
	
	private int num=30;
	private Lock lock = new ReentrantLock();
	
	public void sale() {
		lock.lock();
		try {
			if(num>0) {
				System.out.println(Thread.currentThread().getName()+".....sale ticket number : "+num--);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
}

用lambda写：

package com.lee.juc.concurrent;

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

public class SaleTicket {

	public static void main(String[] args) {
		
		Ticket ticket = new Ticket();
		
		new Thread(()->{for(int i=0;i<100;i++) {ticket.sale();}},"AA").start();
		new Thread(()->{for(int i=0;i<100;i++) {ticket.sale();}},"BB").start();
		new Thread(()->{for(int i=0;i<100;i++) {ticket.sale();}},"CC").start();
		
	}
}

//票
class Ticket{
	
	private int num=30;
	private Lock lock = new ReentrantLock();
	
	public void sale() {
		lock.lock();
		try {
			if(num>0) {
				System.out.println(Thread.currentThread().getName()+".....sale ticket number : "+num--);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
}

2、Callable

代码：

package com.lee.juc.concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * 在主线程中须要执行比较耗时的操做,但又不想阻塞主线程时.能够把这些对象交给Future对象在后台执行,当主线程须要时,
 * 就能够经过Future对象得到后台做业计算的结果或者执行状态.
 * 
 * 通常FutureTask多用于耗时的计算,主线程能够在完成本身的任务后,再去获取结果.
 * 
 * 仅在计算完成时才能检索结果,若是计算还没有完成,则阻塞get方法.一旦计算完成,就不能再从新开始或取消计算.
 * get方法获取结果只有在计算完成时获取,不然会一直阻塞到任务转入完成状态,而后会返回结果或者抛出异常.
 *
 */
public class CallableDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		FutureTask<Integer> futureTak = new FutureTask<>(new MyThread());
		
		new Thread(futureTak, "AA").start();
		new Thread(futureTak, "BB").start();
		
		System.out.println("...this is main method : "+Thread.currentThread().getName());
		
		Integer aResult = futureTak.get();
		System.out.println("A---->"+aResult);
		
		
		Integer bResult = futureTak.get();
		System.out.println("B---->"+aResult);
		
	}
}

class MyThread implements Callable<Integer>{

	public Integer call() throws Exception {
		System.out.println("this is...call...method : "+Thread.currentThread().getName());
		Thread.sleep(3000);
		return 300;
	}
	
}

3、线程池

代码：

package com.lee.juc.concurrent;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class ExecutorDemo {

	public static void main(String[] args) {
	
		ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
		ScheduledFuture<Integer> scheduledFuture = null;
		try {
			
			for (int i = 0; i < 10; i++) {
				scheduledFuture = scheduledExecutorService.schedule(()->{
					System.out.print(Thread.currentThread().getName()+"...");
					return new Random().nextInt(10);
				}, 2, TimeUnit.SECONDS);
				System.out.println("...."+scheduledFuture.get());
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			scheduledExecutorService.shutdown();
		}
		
		
		
	}
	
	
	

	private static void ExecutorService() {
		//		ExecutorService executorService = Executors.newFixedThreadPool(5);
		//		ExecutorService executorService = Executors.newSingleThreadExecutor();
				ExecutorService executorService = Executors.newCachedThreadPool();
				
				Future<Integer> future = null;
				try {
				
					for(int i=0;i<10;i++) {
						 future = executorService.submit(()->{
							System.out.print(Thread.currentThread().getName()+"...");
							return new Random().nextInt(10);
						 });
						 
						 System.out.println("...."+future.get());
					}
					
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					executorService.shutdown();
				}
	}
	
}

4、CountDownLatch

代码：

package com.lee.juc.concurrent;

public enum CountryEnum {

	ONE(1,"韩"),TWO(2,"赵"),THREE(3,"燕"),FOUR(4,"魏"),FIVE(5,"楚"),SIX(6,"齐");
	
	private Integer code;
	private String message;
	
	
	private CountryEnum(Integer code, String message) {
		this.code = code;
		this.message = message;
	}


	public Integer getCode() {
		return code;
	}


	public void setCode(Integer code) {
		this.code = code;
	}


	public String getMessage() {
		return message;
	}


	public void setMessage(String message) {
		this.message = message;
	}
	
	public static CountryEnum foreachCountryEnums(Integer index) {
		for(CountryEnum countryEnum : values()) {
			if(countryEnum.getCode() == index) {
				return countryEnum;
			}
		}
		return null;
	}


	
	
}

//=================================================================

package com.lee.juc.concurrent;

import java.util.concurrent.CountDownLatch;
/**
 *	让一些线程阻塞直到另外一些线程完成后,才被唤醒
 *
 * 	6国被灭后，秦才一统华夏
 */
public class CountDownLatchDemo {

	public static void main(String[] args) throws InterruptedException {
		
		CountDownLatch latch = new CountDownLatch(6);
		
		for (int i = 1; i <= 6; i++) {
			new Thread(()->{
				System.out.println(Thread.currentThread().getName()+"\t国被灭");
				latch.countDown();
			}, CountryEnum.foreachCountryEnums(i).getMessage()).start();
		}
		
		latch.await();
		
		System.out.println(Thread.currentThread().getName()+"....."+"秦灭六国,一统华夏");
		
	}
	
}

5、Semaphore

代码：

package com.lee.juc.concurrent;

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
 *	在信号量上咱们定义两种操做：
 *		acquire（获取）,当一个线程调用acquire操做时,他要么成功经过获取信号量(信号量减1),要么一直等下去,直到有线程释放信号量,或超时.
 *		release（释放）,实际上会将信号量的值加1,而后唤醒等待的线程.
 *
 *	信号量主要用于两个目的：
 *		一个是用于共享资源的互斥.
 *		另外一个是用于并发线程的控制.
 *
 *	eg：模拟6辆车,抢3个停车位.
 *
 */
public class SemaphoreDemo {

	public static void main(String[] args) {
		Semaphore semaphore = new Semaphore(3);//模拟三个车位
		
		for (int i = 0; i < 6; i++) { //模拟6辆车
			
			try {
				new Thread(()->{
					try {
						semaphore.acquire();//占领车位
						System.out.println(Thread.currentThread().getName()+"  占领车位...");

						TimeUnit.SECONDS.sleep(new Random().nextInt(5));//占领一段时间
						System.out.println("...."+Thread.currentThread().getName()+"离开车位");
						
					} catch (Exception e) {
						e.printStackTrace();
					} finally {
						semaphore.release();
					}
				}, String.valueOf(i)).start();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				
			}
			
			
		}
		
	}
}

6、CyclicBarrier

代码：

package com.lee.juc.concurrent;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

/**
 * cyclic可循环的  barrier栅栏、屏障
 * 		让一组线程达到屏障时（阻塞点）被阻塞，直到最后一个线程也达到了屏障时，屏障才会打开，全部被屏障的线程才会继续干活。
 * 		 
 *	eg:集齐七颗龙珠，召唤神龙
 */
public class CyclicBarrierDemo {

	private static final Integer NUMBER = 7;
	public static void main(String[] args) {
		
		CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{System.out.println("召唤神龙!");});
		
		for (int i = 0; i < NUMBER; i++) {
			Integer temp = i;
			new Thread(()->{
				
				try {
					TimeUnit.SECONDS.sleep(new Random().nextInt(5));//手机龙珠的过程
					System.out.println(Thread.currentThread().getName()+"\t收集到第"+temp+"颗龙珠");
					cyclicBarrier.await();//等着其余龙珠被收集
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					e.printStackTrace();
				}
				
			},String.valueOf(i)).start();
		}
		
	}
}