勤奋者废寝忘食，懒惰人总没有时间。
你好，我是梦阳辰，期待与你相遇！
第一种，基础Thread类。
第二种，实现Runable接口。
第三种：实现Callable接口
callable接口与runnable接口的区别?
1）是否有返回值（泛型）
2）是否抛异常
3）落地方法不一样，一个是run，一个是call
报错，因为Thread构造方法需要的是Runable接口，没有Callable接口。
解决方法：我没有那个女孩子的联系方式，但是我知道她朋友的联系方式，你说该怎么解决。
找到Runable的子接口RunnableFuture <V>并找到其实现类：java.util.concurrent.FutureTask，发现其构造方法：
FutureTask(Callable<V> callable)
创建一个 FutureTask ，它将在运行时执行给定的 Callable 。
FutureTask(Runnable runnable, V result)
创建一个 FutureTask ，将在运行时执行给定的 Runnable ，并安排 get将在成功完成后返回给定的结果。
来：
package Part3;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("you can very dance!");
return "ok";
}
}
public class CallableThread {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new MyThread());//future这个对象实现了Runable接口
new Thread(futureTask,"t1").start();//多态
System.out.println(futureTask.get());
}
}
可以获取线程执行的返回值。
一个fureTask对象，只会调用一次线程。
package Part3;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("you can very dance!");
return "ok";
}
}
public class CallableThread {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask futureTask = new FutureTask(new MyThread());//future这个对象实现了Runable接口
new Thread(futureTask,"t1").start();//多态
new Thread(futureTask,"t2").start();//多态
System.out.println(futureTask.get());
}
}
结果只有一个。
java.util.concurrent.CountDownLatch
允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。
A CountDownLatch用给定的计数初始化。 await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await 调用立即返回。 这是一个一次性的现象 - 计数无法重置。 如果您需要重置计数的版本，请考虑使用CyclicBarrier 。
CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。
CountDownLatch(int count)
构造一个以给定计数 CountDownLatch CountDownLatch。
例如:
让其它线程做完后，主线程才离开。
package Part3;
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(6);
//创建6个线程
for(int i=1;i<=6;i++){
int finalI = i;
new Thread(()->{
System.out.println(finalI +"同学离开教室！");
countDownLatch.countDown();//减一
},String.valueOf(i)).start();
}
countDownLatch.await();
//班长离开锁门
System.out.println("班长锁门离开教室！");
}
}
允许一组线程全部等待彼此达到共同屏障点的同步辅助。 循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。 屏障被称为循环 ，因为它可以在等待的线程被释放之后重新使用。
A CyclicBarrier支持一个可选的Runnable命令，每个屏障点运行一次，在派对中的最后一个线程到达之后，但在任何线程释放之前。 在任何一方继续进行之前，此屏障操作对更新共享状态很有用。
等待线程的数量达到一定时：执行特定线程。
构造方法:
CyclicBarrier(int parties)
创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待它时，它将跳闸，并且当屏障跳闸时不执行预定义的动作。
CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。
package Part3;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
System.out.println("人到齐了，可以开会了！");
});
for(int i=1;i<=7;i++){
int temp = i;
new Thread(()->{
System.out.println(temp+"号员工到了！");
try {
cyclicBarrier.await();//等一下其它员工
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
java.lang.Object
java.util.concurrent.Semaphore
一个计数信号量。 在概念上，信号量维持一组许可证。 如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。 每个release()添加许可证，潜在地释放阻塞获取方。 但是，没有使用实际的许可证对象; Semaphore只保留可用数量的计数，并相应地执行。
Semaphore(int permits)
创建一个 Semaphore与给定数量的许可证和非公平公平设置。
Semaphore(int permits, boolean fair)
创建一个 Semaphore与给定数量的许可证和给定的公平设置。
在信号量上我们定义两种操作:
acquire(获取)当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
例如:7辆车抢3个座位。
当只有一个车位就相当于加了synchronized锁
package Part3;
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=1;i<=7;i++){
int temp = i;
new Thread(()->{
try {
semaphore.acquire();//抢车位
System.out.println(temp+"抢到了车位！");
TimeUnit.SECONDS.sleep(3);//停了3秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();//释放车位
}
}).start();
}
}
}
接口：
java.util.concurrent.locks
Interface ReadWriteLock
实现类:
java.lang.Object
java.util.concurrent.locks.ReentrantReadWriteLock
A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的。
所有ReadWriteLock实现必须保证的存储器同步效应writeLock操作（如在指定Lock接口）也保持相对于所述相关联的readLock 。 也就是说，一个线程成功获取读锁定将会看到在之前发布的写锁定所做的所有更新。
读操作可以多个线程操作，多个线程同时读一个资源类没有问题，所以为了满足并发量，读取资源应该可以同时进行，但是如果有一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读写。
例如:
package Part4;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyCache{
private volatile Map<String,Object> map = new HashMap<>();
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void put(String key,Object value){
readWriteLock.writeLock().lock();
try{
System.out.println(Thread.currentThread().getName()+" 写入数据！");
map.put(key,value);
System.out.println(Thread.currentThread().getName()+" 写入成功！");
}finally {
readWriteLock.writeLock().unlock();
}
}
public void get(String key){
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+" 读取数据！");
map.get(key);
System.out.println(Thread.currentThread().getName()+" 读取成功！");
}finally {
readWriteLock.readLock().unlock();
}
}
}
public class ReadWriterLockDemo {
public static void main