Java JUC

synchronized

package juc;

public class SaleTicketDemo01 {
	public static void main(String[] args) {
		Ticket ticket=new Ticket();
		new Thread(()->{
			for (int i = 0; i < 20; i++) {
				ticket.sale();
			}
		},"a").start();
		new Thread(()->{
			for (int i = 0; i < 20; i++) {
				ticket.sale();
			}
		},"b").start();
		new Thread(()->{
			for (int i = 0; i < 20; i++) {
				ticket.sale();
			}
		},"c").start();
	}
}
//资源类
class Ticket{
	//属性，方法
	private int number=50;
	public synchronized void sale() {
		if(number>0) {
			System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"号票，剩余"+number+"张");
		}
	}
}

lock

package juc;

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

public class SaleTicketDemo02 {
	public static void main(String[] args) {
		Ticket2 ticket=new Ticket2();
		new Thread(()->{
			for (int i = 0; i < 20; i++) 	ticket.sale();
		},"a").start();
		new Thread(()->{
			for (int i = 0; i < 20; i++) 	ticket.sale();
		},"b").start();
		new Thread(()->{
			for (int i = 0; i < 20; i++) 	ticket.sale();
		},"c").start();
	}
}
class Ticket2{
	//属性，方法
	private int number=50;
	Lock lock=new ReentrantLock();
	public void sale() {
		lock.lock();
		try {
			//业务代码
			if(number>0) {
				System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"号票，剩余"+number+"张");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

condition

package juc;

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

public class PCDemo01 {
	public static void main(String[] args) {
		Data data=new Data();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				data.increment();
			}
		},"A").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				data.decrement();;
			}
		},"B").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				data.increment();
			}
		},"C").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				data.decrement();
			}
		},"D").start();
	}
}
class Data{
	private int number=0;
	Lock lock=new ReentrantLock();
	Condition condition=lock.newCondition();
	public void increment() {
		try {
			lock.lock();
			while (number!=0) {
				condition.await();
			}
			number++;
			System.out.println(Thread.currentThread().getName()+":"+number);
			condition.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	public void decrement() {
		try {
			lock.lock();
			while (number==0) {
				condition.await();
			}
			number--;
			System.out.println(Thread.currentThread().getName()+":"+number);
			condition.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
}

顺序执行

package juc;

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

public class PCDemo02 {
	public static void main(String[] args) {
		Data2 data2=new Data2();
		new Thread(()->{
			for (int i = 0; i < 10 ; i++)	data2.A();
		},"A").start();
		new Thread(()->{
			for (int i = 0; i < 10 ; i++)	data2.B();
		},"B").start();
		new Thread(()->{
			for (int i = 0; i < 10 ; i++)	data2.C();
		},"C").start();
	}
}
class Data2{
	private Lock lock=new ReentrantLock();
	private Condition condition1=lock.newCondition();
	private Condition condition2=lock.newCondition();
	private Condition condition3=lock.newCondition();
	private int number=1;//1A2B3C
	public void A() {
		lock.lock();
		try {
			while (number!=1) {
				condition1.await();
			}
			System.out.println(Thread.currentThread().getName());
			number=2;
			condition2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	public void B() {
		lock.lock();
		try {
			while (number!=2) {
				condition2.await();
			}
			System.out.println(Thread.currentThread().getName());
			number=3;
			condition3.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
	public void C() {
		lock.lock();
		try {
			while (number!=3) {
				condition3.await();
			}
			System.out.println(Thread.currentThread().getName());
			number=1;
			condition1.signal();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
	}
}

List

package juc;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
	public static void main(String[] args) {
		List<String> list=new CopyOnWriteArrayList<String>();
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				list.add(UUID.randomUUID().toString().substring(0, 5));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}

Callable

package juc;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
	public static void main(String[] args) {
		MyThread myThread=new MyThread();
		FutureTask<Integer> futureTask=new FutureTask<Integer>(myThread);
		new Thread(futureTask,"A").start();//结果会被缓存
		try {
			Integer t=futureTask.get();
			System.out.println(t);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
class MyThread implements Callable<Integer>{
	public Integer call() {
		System.out.println("call");
		return 1024;
	}
}

CountDownLatch

package juc;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch cLatch=new CountDownLatch(6);
		for (int i = 0; i < 6; i++) {
			new Thread(()->{
				System.out.println(Thread.currentThread().getName());
				cLatch.countDown();
			},String.valueOf(i)).start();
		}
		cLatch.await();
		System.out.println("end");
	}
}

CyclicBarrier

package juc;

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

public class CyclicBarrierDemo {
	public static void main(String[] args) {
		CyclicBarrier cBarrier=new CyclicBarrier(7,()->{
			System.out.println("end");
		});
		for (int i = 0; i < 7; i++) {
			final int temp=i;
			new Thread(()->{
				System.out.println(temp);
				try {
					cBarrier.await();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				} catch (BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}).start();
		}
	}
}

Semaphore

package juc;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
	public static void main(String[] args) {
		Semaphore semaphore=new Semaphore(3);
		for (int i = 0; i < 6; i++) {
			new Thread(()->{
				try {
					semaphore.acquire();
					System.out.println(Thread.currentThread().getName()+"in");
					TimeUnit.SECONDS.sleep(1);
					System.out.println(Thread.currentThread().getName()+"out");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					semaphore.release();
				}	
			},String.valueOf(i)).start();
		}
	}
}

Queue

package juc;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class QueueTest {
	public static void main(String[] args) {
		new QueueTest().test1();
		new QueueTest().test2();
		new QueueTest().test3();
		new QueueTest().test4();
	}
	public void test1() {
		ArrayBlockingQueue<Object> bQueue=new ArrayBlockingQueue<Object>(3);
		System.out.println(bQueue.add("a"));
		System.out.println(bQueue.add("b"));
		System.out.println(bQueue.add("c"));
		//java.lang.IllegalStateException: Queue full
		//System.out.println(bQueue.add("a"));
		System.out.println(bQueue.element());
		System.out.println(bQueue.remove());
		System.out.println(bQueue.remove());
		System.out.println(bQueue.remove());
		//Exception in thread "main" java.util.NoSuchElementException
		//System.out.println(bQueue.remove());
	}
	public void test2() {
		ArrayBlockingQueue<Object> bQueue=new ArrayBlockingQueue<Object>(3);
		System.out.println(bQueue.offer("a"));
		System.out.println(bQueue.offer("b"));
		System.out.println(bQueue.offer("c"));
		System.out.println(bQueue.offer("d"));
		System.out.println(bQueue.peek());
		System.out.println(bQueue.poll());
		System.out.println(bQueue.poll());
		System.out.println(bQueue.poll());
		System.out.println(bQueue.poll());
	}
	public void test3(){
		ArrayBlockingQueue<Object> bQueue=new ArrayBlockingQueue<Object>(3);
		try {
			bQueue.put("a");
			bQueue.put("b");
			bQueue.put("c");
			//bQueue.put("d");
			System.out.println(bQueue.take());
			System.out.println(bQueue.take());
			System.out.println(bQueue.take());
			//System.out.println(bQueue.take());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	public void test4() {
		ArrayBlockingQueue<Object> bQueue=new ArrayBlockingQueue<Object>(3);
		try {
			bQueue.offer("A",2, TimeUnit.SECONDS);
			bQueue.offer("b",2, TimeUnit.SECONDS);
			bQueue.offer("a",2, TimeUnit.SECONDS);
			bQueue.offer("s",2, TimeUnit.SECONDS);
			System.out.println(bQueue.poll(2, TimeUnit.SECONDS));
			System.out.println(bQueue.poll(2, TimeUnit.SECONDS));
			System.out.println(bQueue.poll(2, TimeUnit.SECONDS));
			System.out.println(bQueue.poll(2, TimeUnit.SECONDS));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

ThreadPoolExecutor

package juc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo {
	public static void main(String[] args) {
		System.out.println(Runtime.getRuntime().availableProcessors());
		ExecutorService threadpool=new ThreadPoolExecutor(
				2, 
				5, 
				3, 
				TimeUnit.SECONDS,
				new LinkedBlockingQueue<Runnable>(3),
				Executors.defaultThreadFactory(),
				new ThreadPoolExecutor.DiscardOldestPolicy());
		try {
			for (int i = 0; i < 9; i++) {
				threadpool.execute(()->{
					System.out.println(Thread.currentThread().getName());
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			threadpool.shutdown();
		}
	}
}

ForkJoin

package juc;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo extends RecursiveTask<Long>{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ForkJoinPool forkJoinPool=new ForkJoinPool();
		ForkJoinTask<Long> forkJoinTask=new ForkJoinDemo(0,10_0000_0000);
		ForkJoinTask<Long> sunmit=forkJoinPool.submit(forkJoinTask);
		long sum=sunmit.get();
		System.out.println(sum);
	}
	private long start;
	private long end;
	private long temp=10000L;
	public ForkJoinDemo() {
	}
	public ForkJoinDemo(long start,long end) {
		this.start=start;
		this.end=end;
	}
	
	@Override
	protected Long compute() {
		if((end-start)<temp) {
			long sum=0L;
			for(long i=start;i<=end;i++)	sum+=i;
			return sum;
		}
		else {
			long mid=(start+end)/2;
			ForkJoinDemo fDemo1=new ForkJoinDemo(start,mid);
			fDemo1.fork();
			ForkJoinDemo fDemo2=new ForkJoinDemo(mid+1,end);
			fDemo2.fork();
			return fDemo1.join()+fDemo2.join();
		}
	}
	

}