1.sleep()和wait()的区别？
sleep和wait的功能类似，都是让线程暂停执行任务。
- sleep是Thread类提供的方法，wait是Object类提供的方法
- sleep是直接作用于线程对象本身，wait作用于线程正在访问的资源。
调用A对象的wait：让当前正在访问的A对象的线程休眠，同时它拥有一个前提，当前线程必须拥有A对象，所以wait方法只能在同步方法或同步代码块中调用，否则会抛出异常。
- wait会释放锁，sleep不会释放锁。
package com; import java.util.concurrent.TimeUnit; public class Test3 { public static void main(String[] args) { A a = new A(); new Thread(()->{ for (int i = 0; i < 10; i++) { a.test(i); } }).start(); } } class A{ public synchronized void test(int i){ if(i == 5){ //wait没有时间，会一直休眠下去 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i + "-----------------"); } }i == 5时，调用A的wait方法，会让正在访问A的线程休眠，并且永久不会解除阻塞。
2.如何让线程解除阻塞？
- 指定wait的时间，wait(long millis)之后会自动解决阻塞，类似sleep
wait->Object，A继承了Object，A中自带wait方法。
sleep->Thread
class A{ public synchronized void test(int i){ if(i == 5){ //wait没有时间，会一直休眠下去 try { this.wait(5000);//指定时间后，阻塞5秒继续输出(this也可以去掉） } catch (InterruptedException e) { e.printStackTrace(); } } try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i + "-----------------"); } }- 调用notify方法唤醒线程
package com; import java.util.concurrent.TimeUnit; public class Test3 { public static void main(String[] args) { A a = new A(); new Thread(()->{ for (int i = 0; i < 10; i++) { a.test(i); } }).start(); new Thread(()->{ try { TimeUnit.SECONDS.sleep(7); //输出到5时，等待两秒，再继续输出 } catch (InterruptedException e) { throw new RuntimeException(e); } a.test1(); }).start(); } } class A{ public synchronized void test(int i){ if(i == 5){ //wait没有时间，会一直休眠下去 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } try { TimeUnit.SECONDS.sleep(1); //表示1秒输出一个值 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i + "-----------------"); } public synchronized void test1(){ //必须使用synchronized修饰 this.notify(); } }wait和notify方法必须放到同步方法或者同步代码中，否则会抛出异常。
3.synchronized锁定的是谁？
- 如果synchronized修饰非静态方法，则锁定的是方法的调用者
import java.util.concurrent.TimeUnit; public class SyDemo { public static void main(String[] args) { Data data = new Data(); new Thread(()->{ data.func1(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { throw new RuntimeException(e); } new Thread(()->{ data.func2(); },"B").start(); } } class Data{ public synchronized void func1(){ try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("1======="); } public synchronized void func2(){ System.out.println("2++++"); } }- 如果synchronized修饰的是静态方法，则锁定的是类，无论有多少个对象，都会同步。
4.ConcurrentModificationException并发修改异常
并发修改：多个线程对同一个对象进行修改。
import java.util.ArrayList; import java.util.List; public class Bfxg { public static void main(String[] args) { List<String>list = new ArrayList<>(); for (int i = 0; i < 10; i++) { new Thread(()->{ try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } list.add("a"); System.out.println(list); }).start(); } } }由于同时读，同时写，产生了异常。
ArrayList是线程不安全的集合，当多个线程同时操作集合时，会出现数据不准确的情况。
5.ConcurrentModificationException如何解决？
将ArrayList替换成线程安全的集合Vector
Vector中add方法是synchronized修饰
public synchronized boolean add(E e) { modCount++; add(e, elementData, elementCount); return true; }ArrayList中的add方法
public boolean add(E e) { modCount++; add(e, elementData, size); return true; }使用Collections.synchronizedList
import java.util.*; public class Bfxg { public static void main(String[] args) { // List<String> list = new ArrayList<>(); // List<String>list = new Vector<>(); List<String> list = Collections.synchronizedList(new ArrayList<>()); for (int i = 0; i < 10; i++) { new Thread(()->{ try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } list.add("a"); System.out.println(list); }).start(); } } }JUC工具类CopyOnWriteArrayList
java.util.concurrent JDK的一个包，存放的都是关于并发的工具类。
写时复制。
import java.util.*; import java.util.concurrent.CopyOnWriteArrayList; public class Bfxg { public static void main(String[] args) { List<String> list = new CopyOnWriteArrayList<>(); for (int i = 0; i < 10; i++) { new Thread(()->{ try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } list.add("a"); System.out.println(list); }).start(); } } }copyOnWrite写时复制，当我们往一个容器中添加元素的时候，不直接往当前容器中添加，而是将当前容器复制，向新容器中添加元素，添加完成之后，再将原容器的引用指向新的容器。
public boolean add(E e) { synchronized (lock) { Object[] es = getArray(); int len = es.length; es = Arrays.copyOf(es, len + 1); es[len] = e; setArray(es); return true; } }可以对CopyOnWrite容器进行并发的读，因为当前容器不会添加任何元素，添加元素都是针对复制出来的新集合进行操作，所以CopyOnWrite容器也是一种读写分明的思想，读和写操作的是不同容器。
6.JUC常见并发编程工具包
CountDownLatch
减法计数器，JUC的工具类，可以用来倒计时，当两个线程同时执行时，如果我们要确保一个线程优先执行，设置一个计数器，当计数器清零的时候，再执行另一个线程。
import java.util.concurrent.CountDownLatch; public class CountDownLatchTest { public static void main(String[] args) { CountDownLatch countDownLatch = new CountDownLatch(100);//因为需要循环100次 new Thread(()->{ for (int i = 0; i < 100; i++) { System.out.println("+++++++++++Thread"); countDownLatch.countDown(); } }).start(); //判断是否清零 try { countDownLatch.await();//注意：这里是await，不是wait，如果使用wait，会报异常，且不会执行main------ } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i < 100; i++) { System.out.println("main-----------"); } } }CyclicBarrier
加法计数器
import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierTest { public static void main(String[] args) { CyclicBarrier cyclicBarrier = new CyclicBarrier(10,()->{ System.out.println("放行"); }); for (int i = 0; i < 30; i++) { final int temp = i; new Thread(()->{ System.out.println("-->" + temp); try { cyclicBarrier.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } }).start(); } } }Semaphore
计数信号量，实际开发中主要用来完成限流操作，即限制可以访问某些资源的线程数量。
- 初始化
- 获得许可
- 释放
import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class SemaphoreTest { public static void main(String[] args) { Semaphore semaphore = new Semaphore(5); for (int i = 0; i < 15; i++) { new Thread(()->{ try { semaphore.acquire();//获取许可 System.out.println(Thread.currentThread().getName() + "进店购买"); TimeUnit.SECONDS.sleep(2); System.out.println(Thread.currentThread().getName() + "出店"); } catch (InterruptedException e) { e.printStackTrace(); }finally { semaphore.release();//释放 } },String.valueOf(i)).start(); } } }读写锁
接口ReadWriteLock，实现类ReentrantReadWriteLock,可以多线程同时读，但是同一时间只能有一个线程进行写入操作。
读写锁功能也是为了实现线程同步，只不过粒度更细，可以分别给读和写操作设置不同的锁机制。
import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockTest { public static void main(String[] args) { Cache cache = new Cache(); for (int i = 0; i < 5; i++) { final int temp = i; new Thread(()->{ cache.write(temp,String.valueOf(temp)); }).start(); } for (int i = 0; i < 5; i++) { final int temp = i; new Thread(()->{ cache.read(temp); }).start(); } } } class Cache{ private Map<Integer,String> map = new HashMap<>(); ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); //写操作 public void write(Integer key,String value){ readWriteLock.writeLock().lock(); System.out.println(key + "开始写入"); map.put(key, value); System.out.println(key + "写入完毕"); readWriteLock.writeLock().unlock(); } //读操作 public void read(Integer key){ readWriteLock.readLock().lock(); System.out.println(key + "开始读取"); map.get(key); System.out.println(key + "读取完毕"); readWriteLock.readLock().unlock(); } }7.线程池
预先创建好一定数量的线程对象，存入缓冲池，需要用的时候直接从缓冲池中取出，用完后还回到缓冲池中，供下一次任务使用。
优点
- 提高线程的利用率
- 提高响应速度
- 便于统一管理线程对象
- 可控制最大并发量
工作流程
- 初始化线程池，创建默认数量的线程对象
- 当任务过多的时候，额外补充线程数量
- 当任务趋于正常时，额外补充的线程会自动销毁
初始化线程数量
最大线程数量
线程池的实现(3种）
import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Pool { public static void main(String[] args) { // //单例线程池，只有一个线程对象 // ExecutorService executorService = Executors.newSingleThreadExecutor(); // ExecutorService executorService = Executors.newFixedThreadPool(5); //缓存线程池，不同性能的电脑分配的不一样 ExecutorService executorService = Executors.newCachedThreadPool(); for (int i = 0; i < 10; i++) { final int temp = i; executorService.execute(()->{ System.out.println(Thread.currentThread().getName() + ":" + temp); }); } executorService.shutdown(); } }public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }ThreadPoolExecutor 线程池的原生类
核心参数
- corePoolSize:核心池大小
- maximumPoolSize:线程池最大线程数
- keepAliveTime:空闲线程的存活时间
- unit：时间单位
- workQueue:阻塞队列
- threadFactory:线程工厂
- handler：拒绝策略
import java.util.concurrent.*; public class Pool { public static void main(String[] args) { ExecutorService executorService = new ThreadPoolExecutor(2,5,1L, TimeUnit.SECONDS,new ArrayBlockingQueue<>(3),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 2; i++) { executorService.execute(()->{ try { TimeUnit.SECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在办理业务"); }); } executorService.shutdown(); } }
