线程
一、线程创建的3种方式
1、继承Thread 类
public class Thread implements Runnable
重写run方法即可
public class ThreadTest extends Thread {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("继承Thread方法实现多线程");
}
}
//调用
ThreadTest th1=new ThreadTest();
th1.start();
2、实现Runnable接口
本质上和继承Thread类一样，因为Thread类也实现了Rannable接口
public class ThreadTest1 implements Runnable{
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("实现Runable的线程开启方式");
}
}
3、实现Callable接口并返回值
public class ThreadTest2 implements Callable<String> {
@Override
public String call() throws Exception {
Thread.sleep(2000);
return "hello";
}
}
//调用
Callable<String> callable = new ThreadTest2();
FutureTask<String> task=new FutureTask<>(callable);
Thread th4 = new Thread(task);
th4.start();
//task.get() 获取返回值
//这个get方法可能会产生阻塞
System.out.println("从子线程中获取:"+task.get());
分析：FutureTask 实现RunnableFuture,RunnableFuture继承了Runnable接口
public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V>
二、线程池
//ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
//ExecutorService threadPool =Executors.newFixedThreadPool(5);//创建固定的线程池大小
//ExecutorService threadPool =Executors.newCachedThreadPool();//可伸缩的线程池
/**
* 最大线程该如何定义
*
* 1. CPU密集型，几核CPU就定义为几，可以保证CPU效率最高 Runtime.getRuntime().availableProcessors()
* 2. IO 密集型 判断你程序中十分消耗IO的线程数
*/
System.out.println("CPU核心数："+Runtime.getRuntime().availableProcessors());
//自定义线程池 工作中，使用ThreadPoolExecutor 自己创建
ExecutorService threadPool=new ThreadPoolExecutor(2,//核心线程池大小
5,//最大线程池大小
3,//非核心线程闲置存活时间
TimeUnit.SECONDS,//超时单位
new LinkedBlockingQueue<>(5),//阻塞队列
Executors.defaultThreadFactory(),//线程工厂，创建线程,一般不修改
new ThreadPoolExecutor.AbortPolicy()//拒绝策略：对新来的线程不做处理，抛出异常
);
//阻塞队列存放个数+最大线程池个数=同时允许使用线程池的个数
for(int i=0;i<10;i++){
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName());
});
}
//线程池使用完，程序结束，要关闭线程池
threadPool.shutdown();
拒绝策略
AbortPolicy()//对新来的线程不做处理，抛出异常
CallerRunsPolicy()//哪来的回哪里，用线程池的线程处理
DiscardPolicy()//队列满了，丢弃当前任务，不会抛出异常
DiscardOldestPolicay()//队列满了，把队列首个poll丢出，自己加入队列，不抛出异常 e.getQueue().poll();
并发
1、synchronized
非静态方法上
锁的对象是 该方法的类的实例
静态方法上
锁的对象是类的字节码 如：Person.class
同步代码块
锁的对象是自己定义的
2、ReentrantLock
创建锁
Lock lock = new ReentrantLock();
加锁
lock.lock();
解锁
lock.unlock();
3、CAS
java.util.concurrent.atomic
//CAS compareAndSet() 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
//如果我期望的值达到了，就更新
atomicInteger.compareAndSet(2020,2021);
System.out.println(atomicInteger.get());
}
线程之间的通信
等待唤醒 synchronized
public synchronized void incrnumber() throws InterruptedException {
while (number!=0){//不要用if判断，应该用while防止虚假唤醒
//等待
this.wait();
}
number ++;
System.out.println(Thread.currentThread().getName()+"number="+number);
//通知其他线程
this.notifyAll();
}
等待唤醒 ReentrantLock
private int number=0;
final Lock lock=new ReentrantLock();
final Condition conditionA = lock.newCondition();
final Condition conditionB = lock.newCondition();
//condition.wait();//等待
//condition.signalAll();//唤醒全部
//+1
public void incrnumber() throws InterruptedException {
//1、加锁
lock.lock();
try{
while (number!=0){//不要用if判断，应该用while防止虚假唤醒
// A 等待
conditionA.await();
}
number ++;
System.out.println(Thread.currentThread().getName()+" number="+number);
//唤醒 B
conditionB.signal();
}catch (Exception e){}finally {
//解锁
lock.unlock();
}
}
//-1
public void decrnumber() throws InterruptedException {
//加锁
lock.lock();
try{
while(number==0){
//B 等待
conditionB.await();
}
number-- ;
System.out.println(Thread.currentThread().getName()+" number="+number);
//唤醒 A
conditionA.signal();
}catch (Exception e){}
finally {
//解锁
lock.unlock();
}
}
减法计数器CountDownLatch
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i=0;i<6;i++){
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"---go---out");
//数量 减1
countDownLatch.countDown();
},String.valueOf(i)).start();
}
//等待计数器归零 再向下执行
countDownLatch.await();
System.out.println("执行 完成 6");
加法计数器CyclicBarrier
/**
* 集齐7颗龙珠召唤神龙
*/
//计数，线程
//如果收集不齐，会阻塞
CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{
System.out.println("召唤神龙成功");
});
for(int i=0;i<7;i++){
new Thread(()->{
//这里面如果要拿外面的变量，需要拿 final 类型变量
System.out.println(Thread.currentThread().getName()+":收集龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
读写锁ReadWriteLock
/**
* 独占锁：写锁 一次只能被一个线程占有
* 共享锁：读锁 可以被多个线程拥有
*
* 读-读：共存
* 读-写：不能共存
* 写-写：不能共存
*/
class MyCacheLock{
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()+"写入OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁
readWriteLock.writeLock().unlock();
}
}
//取 所有人都可以读
public void get(String key){
//读锁
readWriteLock.readLock().lock();
try {
map.get(key);
System.out.println(Thread.currentThread().getName()+"读取");
} catch (Exception e) {
e.printStackTrace();
} finally {
//释放锁
readWriteLock.readLock().unlock();
}
}
}
信号量Semaphore
Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。
Semaphore的主要方法摘要：
void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
void release():释放一个许可，将其返回给信号量。
int availablePermits():返回此信号量中当前可用的许可数。
boolean hasQueuedThreads():查询是否有线程正在等待获取。
/**
* 抢车位
* 如果已经满了，一直等待直到释放为止
*/
//作用：多个共享资源互斥的使用 并发限流，控制最大线程数
public static void main(String[] args) {
//线程数量 有3个停车位
final Semaphore semaphore = new Semaphore(3);
for (int i=0;i<6;i++){
new Thread(()->{
//得到/获取 semaphore.acquire();
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"抢到车位");
//停两秒钟
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//离开车位
semaphore.release();
}
//释放 semaphore.release();
},String.valueOf("线程"+i)).start();
}
}
并发集合
1、List
//并发下arraylist是不安全的
// List<String> list = new ArrayList<>();
//1、解决方案 1
//List<String> list = new Vector<>();
//解决方案 2
// List<String> list =Collections.synchronizedList(new ArrayList<>());
//解决方案 3 写入时复制COW 计算机程序设计领域的一种优化策略
//CopyOnWriteArrayList 比Vector好，Vector有syncthronized，效率会降低
List<String> list=new CopyOnWriteArrayList<>();
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();
}
2、Set
//Set集合在多线程下 也是不安全的
// Set<String> set = new HashSet<>();
//1解决方案
Set<String> set= Collections.synchronizedSet(new HashSet<>());
//2解决方案
// Set<String> set=new CopyOnWriteArraySet<>();
for(int i=0;i<30;i++){
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
3、Map
//Map集合在多线程下 也是不安全的
Map<String,String> map = new HashMap<>();
//1解决方案
//Map<String,String> map= Collections.synchronizedMap(new HashMap<>());
//2解决方案
//Map<String,String> map=new ConcurrentHashMap<>();
for(int i=0;i<30;i++){
new Thread(()->{
map.put(UUID.randomUUID().toString().substring(0,5),"AAAA");
System.out.println(map);
},String.valueOf(i)).start();
}
BlockingQueue
ArrayBlockingQueue
public static void main(String[] args) {
//collection
//List
//Set
//BlockingQueue 不是新的东西
/**
* 什么情况下使用 阻塞队列
* 多线程：线程池，多线程并发处理 A 调用 B
*
*/
}
//抛出异常
@Test
public void test1(){
//要设置队列的大小
ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(arrayBlockingQueue.add("a"));
System.out.println(arrayBlockingQueue.add("b"));
System.out.println(arrayBlockingQueue.add("c"));
//java.lang.IllegalStateException: Queue full
//超过大小会抛出异常
//System.out.println(arrayBlockingQueue.add("c"));
//移除元素并返回 移除的元素
System.out.println(arrayBlockingQueue.remove());
System.out.println(arrayBlockingQueue.remove());
System.out.println(arrayBlockingQueue.remove());
//java.util.NoSuchElementException
//没有元素后移除会抛出异常
//System.out.println(arrayBlockingQueue.remove());
}
/**
* 不抛出异常
*/
@Test
public void test2(){
ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
//element()监测 队列首个元素，要抛出异常
//arrayBlockingQueue.element();
//peek监测 队列首个元素 没有返回null 不抛出异常
//System.out.println(arrayBlockingQueue.peek());
//存值 offer
System.out.println(arrayBlockingQueue.offer("a"));
System.out.println(arrayBlockingQueue.offer("b"));
System.out.println(arrayBlockingQueue.offer("c"));
//满了 不抛出异常，返回 Boolean 值
System.out.println(arrayBlockingQueue.offer("d"));
// element() 返回队列首个元素值，不做移除
System.out.println(arrayBlockingQueue.element());
System.out.println(arrayBlockingQueue.peek());
//移除 poll 返回移除的值
System.out.println(arrayBlockingQueue.poll());
System.out.println(arrayBlockingQueue.poll());
System.out.println(arrayBlockingQueue.poll());
//若移除空了 没有值返回null
System.out.println(arrayBlockingQueue.poll());
}
/**
* 等待，阻塞（一直阻塞）
*/
public void test3() throws InterruptedException {
ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
//存值 put
arrayBlockingQueue.put("a");
arrayBlockingQueue.put("b");
arrayBlockingQueue.put("c");
//队列没有位置了，会一直等待 阻塞
//arrayBlockingQueue.put("d");
//取值 take()
System.out.println(arrayBlockingQueue.take());
System.out.println(arrayBlockingQueue.take());
System.out.println(arrayBlockingQueue.take());
//如果没有元素 会一直阻塞
System.out.println(arrayBlockingQueue.take());
}
/**
* 等待，阻塞（等待超时）
*/
@Test
public void test4() throws InterruptedException {
ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
//存 offer
arrayBlockingQueue.offer("a",2, TimeUnit.SECONDS);
arrayBlockingQueue.offer("a",2, TimeUnit.SECONDS);
arrayBlockingQueue.offer("a",2, TimeUnit.SECONDS);
//队列满了等待2秒 等待超过两秒就退出
arrayBlockingQueue.offer("a",2, TimeUnit.SECONDS);
//取 poll
arrayBlockingQueue.poll(2,TimeUnit.SECONDS);
arrayBlockingQueue.poll(2,TimeUnit.SECONDS);
arrayBlockingQueue.poll(2,TimeUnit.SECONDS);
//等待超过两秒 队列中还没有值就 超时退出
arrayBlockingQueue.poll(2,TimeUnit.SECONDS);
}
总结：
1、add() remove() 添加 移除，当添加时超过大小，移除时没有元素时抛出异常
2、offer() poll() 存值、取值，存值时空间不够返回false，取值时没有时返回Null
3、put() take() 存值、取值 ，存值时空间不够会阻塞，取值时没有元素会一直阻塞
4、offer() pool()，设置阻塞等待的时间，超过时间没有存值或取值就放弃等待退出
SynchronousQueue
/**
* 同步队列
* 和其他的BlockingQueue 不一样 ，SynchronousQueue不存元素
* put 了一个元素，必须从里面先take取出来，否则不能在put进去值
*/
public class SynchronousQueueDemo {
@Test
public void Test1() throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
BlockingQueue<String> queue = new SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"put 1");
queue.put("1");
System.out.println(Thread.currentThread().getName()+"put 2");
queue.put("2");
System.out.println(Thread.currentThread().getName()+"put 3");
queue.put("3");
} catch (Exception e) {
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
},"t1").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"take"+queue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"take"+queue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"take"+queue.take());
} catch (Exception e) {
e.printStackTrace();
}finally {
countDownLatch.countDown();
}
},"t2").start();
countDownLatch.await();
}
}
