对于多线程JUC的一些总结

进程，线程，程序

进程是系统进行资源分配的和调度的最小单位。是程序执行的一个实例。即一个运行着的程序，也是线程的容器。

线程是操作系统能够进行运算调度的最小单位。包含在进程当中，是进程中实际运作单位，一个线程是进程中的一个条运行路径。一个进程可以有多个线程。

程序是指存储在磁盘上的静态代码。

并行与并发

并行是指同一个时刻多个任务在同时执行，一般存在于多核处理器中

并发是指同一个时间段，多个任务在同时进行，但是细化到时刻是只有一个任务在执行的。

线程的状态

Sleep和Wait的异同

相同：都能使线程阻塞，都会被interrupt中断

不同：声明位置，sleep是在线程中，wait是在object类中

​ 调用要求不一样，sleep能在任意场景下调用因为每一个运行流程都是一个线程，wait只能在同步代码块中调用

​ sleep不释放锁，wait会释放锁。

线程之间的通信

synchronized实现线程间通信
wait(): 释放锁后线程阻塞
notify()：唤醒优先级高的一个线程
notifyAll()：唤醒所有线程
lock中线程通信
调用Lock中的Condition方法

集合的线程安全

Vector HashTable

Vector是线程安全的通过sychronizied关键字实现，由于同步机制需要消耗资源，所以Vector性能相对较差。
HashTable也是相同的情况。
Vector和HashTable在add方法中也添加了sychronizied关键字，这就会产生读读互斥的现象。

为了解决这个问题引入了CopyOnWriteArrayList和ConcurrentHashMap集合，这两种方法锁的颗粒度更小，性能相对更好。

JUC中的辅助类

减少计数

方法摘要：

主要是设置一个计数器，然后使用await方法等待计数器减到0，再执行。

package juc.second;

import java.util.concurrent.CountDownLatch;

class foo2{
	CountDownLatch count = new CountDownLatch(2);
	
	public void first() {
		try {
			count.await();
			System.out.println(Thread.currentThread().getName()+"开始运行");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void down(int x) {
		for(int i=0;i<x;i++) {
			count.countDown();
			System.out.println(count.getCount());
			System.out.println(Thread.currentThread().getName()+"休息下");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

public class countDownLatch {
	public static void main(String[] args) {
		foo2 foo = new foo2();
		new Thread(()->{
			foo.first();
		}).start();
		new Thread(()->{
			foo.down(10);
		}).start();
	}
}

循环栅栏

设置一个值$x$，直到有$x$个线程处于等待时，一起突破屏障。

package juc.second;

import java.util.concurrent.CyclicBarrier;

class foo3{
	public void first(CyclicBarrier cyclicBarrier) {
		try {
			System.out.println(Thread.currentThread().getName()+"到了");
			cyclicBarrier.await();
//			System.out.println(Thread.currentThread().getName()+"走了");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
		}
	}
}

public class cyclicBarrier {
	public static void main(String[] args) {
		foo3 foo = new foo3();
		CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
			System.out.println("冲破");
		});
		for(int i=0;i<14;i++) {			
			new Thread(()->{
				foo.first(cyclicBarrier);
			}).start();
		}
	}
}

信号灯

Semaphore是Java1.5之后出现的一种同步工具。它可以维护访问自身线程的个数。主要有2个函数。

acquire()获取一个许可。
release()释放一个许可。

举个简单的例子，比如网吧有$5$台机子，但是有$10$。当满了的时候需要有人让出位置下面的才能进去。

import java.util.Random;
import java.util.concurrent.Semaphore;

class foo4{
	private Semaphore semaphore = new Semaphore(20);
	
	public void getComputer() {
		try {
			semaphore.acquire();
			System.out.println(Thread.currentThread().getName()+"获得电脑");
			Random rand = new Random();
			Thread.sleep(rand.nextInt(5000));
			semaphore.release();
			System.out.println(Thread.currentThread().getName()+"下机");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

public class semaphore {
	public static void main(String[] args) {
		foo4 foo = new foo4();
		for(int i=0;i<50;i++) {
			new Thread(()->{
				foo.getComputer();
			}).start();			
		}
	}
}

线程池

这是关于线程池中官方的注释

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */

前四个参数分别是核心线程数，最大线程树，存活时间及其单位。后三个参数为阻塞队列，线程工厂,拒绝策略

阻塞队列

阻塞队列是用来帮我们管理什么时候阻塞线程，什么时候唤醒线程的一个队列。
比如生产者和消费者模型，生产者往阻塞队列里面增加数据，消费者往里面拿数据，通过阻塞队列我们就不要自己管理线程的唤醒与阻塞。

线程工厂

拒绝策略

AbortPolicy(默认)：直接抛出RejectedExecutionException异常阻止系统正常运行。
CallerRunsPolicy：调用者运行机制，该策略下既不会抛弃任务，也不会抛出异常，而是将任务回退给调用者，从而降低新任务的流量
DiscardOlderPolicy：抛弃队列中等待时间最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
DiscardPolicy：该策略默默的抛弃无法处理的任务，不进行任何处理也不抛出异常。