看完后，你再也不用怕面试问并发编程啦

public final void wait();             // 导致当前线程等待
public final native void wait(long timeout) throws InterruptedException;
public final native void notify();    // 唤醒正在等待的单个线程
public final native void notifyAll(); // 唤醒正在等待的全部线程

package cn.itcast.thread;
import java.util.concurrent.TimeUnit;

/**
 * 测试 wait()、notify()、notifyAll()
 */
public class Test1 {

 public static void main(String[] args) {
 // 创建对象
 Object obj = new Object();
 // 线程t1
 new Thread(() -> {
 synchronized (obj) {
 try {
 System.out.println(Thread.currentThread().getName() + "wait 前");
 obj.wait(); // 等待、线程阻塞(释放锁)
 System.out.println(Thread.currentThread().getName() + "wait 后");
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }, "t1:").start();

 // 线程t2
 new Thread(() -> {
 synchronized (obj) {
 try {
 System.out.println(Thread.currentThread().getName() + "wait 前");
 obj.wait(); // 等待、线程阻塞(释放锁)
 System.out.println(Thread.currentThread().getName() + "wait 后");
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }, "t2:").start();

 // 线程t3
 new Thread(() -> {
 synchronized (obj) {
 try {
 // 休眠2秒
 TimeUnit.SECONDS.sleep(2); //目的让前2个线程进入等待状态
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("notifyAll 前");
 obj.notifyAll(); // 唤醒全部等待的线程，不会释放锁
 System.out.println("notifyAll 后");
 }
 }, "t3:").start();
 }

package cn.itcast.thread;

/** 测试: 线程6种状态 */
public class Test2 {

 // 方法1 (RUNNABLE: 运行)
 public static void test1() {
 new Thread(() -> {
 synchronized (Test2.class) {
 while (true) {
 }
 }
 }, "t1-runnable").start(); //线程运行中
 }

 // 方法2 (TIMED_WAITING : 超时等待)
 public static void test2() {
 new Thread(() -> {
 synchronized (Test2.class) {
 while (true) {
 try {
 Test2.class.wait(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
 }, "t2-timed_waiting").start(); //线程超时等待中
 }

 // 方法3
 public static void test3() {
 // (RUNNABLE: 运行)
 new Thread(() -> {
 synchronized (Test2.class) {
 while (true) {
 }
 }
 }, "t3-runnable").start();
 // (BLOCKED: 阻塞)
 new Thread(() -> {
 synchronized (Test2.class) {
 //由于上面没有释放锁，被阻塞中
 }
 }, "t4-BLOCKED").start();
 }

 // 方法4 (WAITING : 等待)
 public static void test4() {
 new Thread(() -> {
 synchronized (Test2.class) {
 while (true) {
 try {
 Test2.class.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
 }, "t5-waiting").start(); //线程等待中
 }

 public static void main(String[] args) {
 //test1(); // 线程运行中
 //test2(); // 线程超时等待中
 test3(); // 线程阻塞中
 //test4(); // 线程等待中
 }
}

package cn.itcast.thread;

/**
 * join() : 加入线程
 * yield() : 线程让步
 * sleep() : 线程休眠
 */
public class Test3 {

    public static void main(String[] args) throws InterruptedException {
        // 线程1
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 20; i++) {
                System.out.println(Thread.currentThread().getName() + i);
                // 线程让步
                //Thread.yield();
            }
        },"t1:");

        // 线程2
        Thread t2 = new Thread(() -> {
            for (int i = 1; i <= 20; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        },"t2:");

        // 启动线程
        t1.start();
        // 加入线程
        t1.join();
        // 设置线程优先级
        //t1.setPriority(Thread.MIN_PRIORITY);

        t2.start();
        // 设置线程优先级
        //t2.setPriority(Thread.MIN_PRIORITY);
    }
}

package cn.itcast.thread;

/** 学习死锁的概念和解决死锁 */
public class DeadLock {

 // 定义两个对象作为锁
 private static Object objA = new Object();
 private static Object objB = new Object();

 public static void main(String[] args) {
 // 线程1
 Thread t1 = new Thread(() -> {
 // 同步锁
 synchronized (objA){
 try {
 // 线程休眠(让出CPU，不释放锁)
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("AAAAAAA");
 // 同步锁
 synchronized (objB){
 System.out.println("BBBBBBB");
 }
 }
 });

 // 线程2
 Thread t2 = new Thread(() -> {
 // 同步锁
 synchronized (objB){
 System.out.println("CCCCCCC");
 // 同步锁
 synchronized (objA){
 System.out.println("DDDDDDD");
 }
 }
 });

 t1.start();
 t2.start();
 }
}

package cn.itcast.thread;

public class Test4 {
    // 定义变量
    private static final long count = 1000000000;

    public static void main(String[] args) throws InterruptedException {
        concurrency();
        serial();
    }

    // 定义方法1(使用线程)
    private static void concurrency() throws InterruptedException {
        long start = System.currentTimeMillis();
        // 创建线程 循环累加
        Thread thread = new Thread(() -> {
            int a = 0;
            for (long i = 0; i < count; i++) {
                a += 5;
            }
        });
        // 开启线程
        thread.start();

        // 循环累减
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        long time = System.currentTimeMillis() - start;
       // thread.join();
        System.out.println("concurrency :" + time + "ms,b=" + b);
    }


    // 定义方法2 (不用线程)
    private static void serial() {
        long start = System.currentTimeMillis();
        // 循环累加
        int a = 0;
        for (long i = 0; i < count; i++) {
            a += 5;
        }
        // 循环累减
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        long time = System.currentTimeMillis() - start;
        System.out.println("serial:" + time + "ms,b=" + b );
    }
}

package cn.itcast.thread;

public class Test5 {
    // 定义flag属性
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {

        // 创建线程1
        new Thread(() -> {
            long num = 0;
            while (!flag){
                num++;
            }
            // 如果没有打印，说明当前线程无法感知flag的修改
            System.out.println("num = " + num);
        }).start();

        // 休眠1000毫秒
        Thread.sleep(1000);

        // 创建线程2
        new Thread(() -> {
            // 修改flag
            flag = true;
            System.out.println("flag = " + flag);
        }).start();
    }
}

package cn.itcast.thread;

/** volatile 实现多线程访问共享成员时的可见性 */
public class Test6 {

 // volatile 实现多线程访问共享成员时的可见性.
 private static volatile boolean flag = false;

 public static void main(String[] args) throws InterruptedException {

 // 创建线程1
 new Thread(() -> {
 long num = 0;
 while (!flag){
 num++;
 }
 // 如果没有打印，说明当前线程无法感知flag的修改
 System.out.println("num = " + num);
 }).start();

 // 休眠1000毫秒
 Thread.sleep(1000);

 // 创建线程2
 new Thread(() -> {
 // 修改flag
 flag = true;
 System.out.println("flag = " + flag);
 }).start();
 }
}

package cn.itcast.thread;

public class Test7 {

 // 无法在多线程的情况下实现原子自递增的问题。
 private static int count = 0;

 // 定义累计的方法
 public synchronized static void inc(){
 try {
 Thread.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 count++;
 }

 public static void main(String[] args) throws InterruptedException {
 // 循环创建线程
 for(int i = 0; i < 1000; i++){
 new Thread(() -> {
 inc();
 }).start();
 }
 Thread.sleep(4000);
 System.out.println("y运行结果："+count);
 }
}

public void execute(){
 int a = 0;
 int b = 1;
 int c = a + b;
}

// x、y为非volatile变量
// flag为volatile变量
 
x = 2; //语句1
y = 0; //语句2
flag = true; //语句3
x = 4; //语句4
y = -1; //语句5

synchronized void setA() throws Exception{
    Thread.sleep(1000);
    setB();
}
synchronized void setB() throws Exception{
    Thread.sleep(1000);
}

package cn.itcast.thread;

/** 学习使用同步代码块解决线程安全问题 */
public class Test8 {

 // 定义票的总数量
 private static int ticket = 100;

 public static void main(String[] args) {

 Runnable runnable = () ->{
 // 循环买票
 while (true){
 try {
 Thread.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 // 同步代码块(类锁)
 synchronized (Test8.class) {
 if (ticket > 0) {
 ticket--;
 System.out.println(Thread.currentThread().getName() +
 "卖了一张票，剩余：" + ticket);
 } else {
 // 票没了
 break;
 }
 }
 }
 };

 // 创建3个线程
 Thread t1 = new Thread(runnable, "窗口1");
 Thread t2 = new Thread(runnable, "窗口2");
 Thread t3 = new Thread(runnable, "窗口3");
 t1.start();
 t2.start();
 t3.start();
 }
}

// 普通同步方法，对当前一个实例对象加锁，多线程操作同一个对象实例进行同步操作
public synchronized void 方法名() {
 ...
}
// 静态同步方法，对类加锁，多线程操作当前类所有实例对象进行同步操作
public static synchronized void 方法名() {
 ...
}

package cn.itcast.thread;

/** 学习使用同步代码块解决线程安全问题 */
public class Test9 {

 // 定义票的总数量
 private static int ticket = 100;

 public static void main(String[] args) {

 Runnable runnable = () ->{
 // 循环买票
 while (true){
 try {
 Thread.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 sell();
 }
 };

 // 创建3个线程
 Thread t1 = new Thread(runnable, "窗口1");
 Thread t2 = new Thread(runnable, "窗口2");
 Thread t3 = new Thread(runnable, "窗口3");
 t1.start();
 t2.start();
 t3.start();
 }

 // 同步方法
 private static synchronized void sell() {
 // 同步代码块(类锁)
 if (ticket > 0) {
 ticket--;
 System.out.println(Thread.currentThread().getName() +
 "卖了一张票，剩余：" + ticket);
 }
 }
}

l.lock(); // 获得锁
    try {
        操作共享资源的代码
    } finally {
        l.unlock(); // 释放锁
    }

package cn.itcast.thread;

import java.util.concurrent.locks.ReentrantLock;

/** 学习使用Lock解决线程安全问题 */
public class Test10 {

    // 定义票的总数量
    private static int ticket = 100;

    public static void main(String[] args) {
        // 创建可重入锁对象
        ReentrantLock lock = new ReentrantLock();

        Runnable runnable = () -> {
            // 循环卖票
            while (true) {
                try {
                    Thread.sleep(10);
                    // 获得锁
                    lock.lock();
                    if (ticket > 0) {
                        ticket--;
                        System.out.println(Thread.currentThread().getName() +
                                "卖了一张票，剩余：" + ticket);
                    } else {
                        break;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放锁
                    lock.unlock();
                }
            }
        };

        // 创建3个线程
        Thread t1 = new Thread(runnable, "窗口1");
        Thread t2 = new Thread(runnable, "窗口2");
        Thread t3 = new Thread(runnable, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

package java.util.concurrent.locks;

public interface ReadWriteLock {

 Lock readLock();

 Lock writeLock();
}

package cn.itcast.thread;
import java.util.concurrent.locks.ReentrantReadWriteLock;

// ReentrantReadWriteLock: 可重入读写锁 (读锁是共享锁，写锁是独享锁)
public class Test11 {

 // 定义可重入读写锁
 private ReentrantReadWriteLock rw = new ReentrantReadWriteLock();

 public static void main(String[] args) {
 final Test11 test = new Test11();
 
 new Thread(() -> {
 test.get(Thread.currentThread());
 }).start();

 new Thread(() -> {
 test.get(Thread.currentThread());
 }).start();
 }

 public void get(Thread thread) {
 // 读锁是共享锁
 rw.readLock().lock();
 // 写锁是独享锁
 //rw.writeLock().lock();
 try {
 for (int i = 0; i < 50; i++){
 System.out.println(thread.getName() + "正在进行读操作");
 }
 System.out.println(thread.getName() + "读操作完毕");
 }finally {
 rw.readLock().unlock();
 //rw.writeLock().unlock();
 }
 }
}

package cn.itcast.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class Test12 implements Runnable {

 // 定义整型并发原子对象
 private static AtomicInteger atomicInteger = new AtomicInteger(0);

 @Override
 public void run() {
 try {
 // 线程休眠
 Thread.sleep(200);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 // 进行原子性操作+1
 System.out.println(atomicInteger.incrementAndGet());
 }

 public static void main(String[] args) throws InterruptedException {
 // 创建List集合
 List<Thread> list = new ArrayList<>();
 Test12 task = new Test12();

 // 开启多线程进行操作共享变量
 for (int i = 0; i <10 ; i++) {
 Thread thread = new Thread(task);
 list.add(thread);
 thread.start();
 }

 for (Thread thread : list) {
 thread.join(); // 确保所有thread全部运行
 }

 System.out.println("递增结果：" + atomicInteger.get());
 }
}

package cn.itcast.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerArray;

public class Test13 implements Runnable{

 // 定义数组
 private static int[] ints = {0,2,3};
 // 定义原子整型数组对象
 private static AtomicIntegerArray atomicIntegerArray
 = new AtomicIntegerArray(ints);

 @Override
 public void run() {
 try {
 // 线程休眠
 Thread.sleep(200);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 // 操作普通数组中的第一个元素 +1
 ints[0] = ints[0] + 1;
 // 操作原子数组中的第一个元素 +1
 System.out.println(atomicIntegerArray.incrementAndGet(0));
 }

 public static void main(String[] args) throws InterruptedException {
 // 创建List集合
 List<Thread> list = new ArrayList<>();
 Test13 task = new Test13();

 // 开启多线程进行操作共享变量
 for (int i = 0; i <10 ; i++) {
 Thread thread = new Thread(task);
 list.add(thread);
 thread.start();
 }

 for (Thread thread : list) {
 thread.join(); // 确保所有thread全部运行
 }

 System.out.println("原子数组操作结果：" + atomicIntegerArray.get(0)); // 10
 System.out.println("普通数组操作结果：" + ints[0]); // 不一定
 }
}

package cn.itcast.thread;

import java.util.concurrent.atomic.AtomicReference;


public class Test14 {

 public static void main(String[] args) {

 // 1. 创建一个User对象封装数据
 User user = new User("李小华", 18);

 // 2. 创建一个原子引用类型AtomicReference操作User类型数据
 AtomicReference<User> atomicReference = new AtomicReference<>();

 // 3. 将user对象的数据存入原子引用类型对象中
 atomicReference.set(user);
 // 4. 更新原子引用类型存储的数据
 atomicReference.compareAndSet(user, new User("李中华", 20));

 // 5. 打印普通user对象数据与原子引用类型对象数据
 System.out.println("普通对象数据："+ user +",对象hashcode: " + user.hashCode());
 System.out.println("原子引用类型对象数据：" + atomicReference.get()
 + ",对象hashcode: " + atomicReference.get().hashCode());
 }
}

package cn.itcast.thread;

public class Test15 {

 public static void main(String[] args) throws InterruptedException {
 // 创建线程1
 Thread t1 = new Thread(() -> {
 System.out.println("parser1 finish");
 });
 // 创建线程2
 Thread t2 = new Thread(() -> {
 System.out.println("parser2 finish");
 });
 t1.start();
 t2.start();
 t1.join(); // join阻塞
 t2.join(); // join阻塞
 System.out.println("join方式: all parser finish");
 }
}

package cn.itcast.thread;

import java.util.concurrent.CountDownLatch;

public class Test16 {

 // 定义倒计数闭锁对象
 private static CountDownLatch countDownLatch = new CountDownLatch(2);

 public static void main(String[] args) throws InterruptedException {
 // 创建线程1
 Thread t1 = new Thread(() -> {
 System.out.println("parser1 finish");
 countDownLatch.countDown(); // 计算递减1
 });
 // 创建线程2
 Thread t2 = new Thread(() -> {
 System.out.println("parser2 finish");
 countDownLatch.countDown(); // 计算递减1
 });
 t1.start();
 t2.start();
 countDownLatch.await(); // 阻塞，计算为0释放阻塞，运行后面的代码
 System.out.println("join方式: all parser finish");
 }
}

package cn.itcast.thread;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

public class Test17 {

    // 定义同步屏障对象
    private static CyclicBarrier cb = new CyclicBarrier(2);

    public static void main(String[] args) {
        // 创建线程1
        new Thread(() -> {
            try {
                System.out.println("达到屏障阻塞线程数：" + cb.getNumberWaiting());
                cb.await(); // 达到屏障阻塞，+1
                System.out.println("运行结束1"); // 不会运行
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();

        // 创建线程2
        new Thread(() -> {
            try {
                System.out.println("达到屏障阻塞线程数：" + cb.getNumberWaiting());
                cb.await(); // 达到屏障阻塞，+1
                System.out.println("运行结束2"); // 不会运行
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();


        try {
            TimeUnit.SECONDS.sleep(2);
            // 会运行，没有到达屏障，不会阻塞
            System.out.println("主线程完成，拦截线程数：" + cb.getParties()
                    + "，达到屏障阻塞线程数：" + cb.getNumberWaiting());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

private static CyclicBarrier cb = new CyclicBarrier(3);

package cn.itcast.thread;

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

public class Test18 {

    public static void main(String[] args) {

        // 1. 创建信号量对象控制并发线程数量，设置许可数5个（同时运行5个线程）
        Semaphore semaphore = new Semaphore(5, true);

        // 2. 循环运行10个线程（会看到每次只允许5个线程）
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    // 2.1 申请获取许可
                    semaphore.acquire();

                    // 2.2 运行业务
                    System.out.println(Thread.currentThread().getName() + "车，进入停车场");
                    TimeUnit.SECONDS.sleep(3);// 让当前线程休眠（让线程多运行一会，方便观察效果）
                    System.out.println(Thread.currentThread().getName() + "车，离开停车场");

                    // 2.3 释放阻塞，增加一个许可（让下一个阻塞的线程运行）
                    semaphore.release();

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore semaphore = new Semaphore(许可数, true); // 公平模式

Semaphore semaphore = new Semaphore(许可数, false); // 非公平模式，(默认)

package cn.itcast.thread;

import java.util.concurrent.Exchanger;

public class Test19 {

    public static void main(String[] args) {

        // 1. 创建交换数据对象，并设置传输数据的类型
        Exchanger<String> exchanger = new Exchanger<>();

        // 2. 启动2个线程进行交换数据
        // 创建线程1
        new Thread(() -> {
            // 2.1 定义交换的数据
            String girl1 = "【柳岩】";
            System.out.println(Thread.currentThread().getName() + "说：我的女友 " + girl1);
            System.out.println(Thread.currentThread().getName() + "说：等待线程2交换数据");
            // 2.2 将数据交换给线程2，并拿到线程2的数据
            try {
                String b = exchanger.exchange(girl1);//注意：如果线程2没有到达同步点，当前线程会被阻塞一直等到
                //成功获取线程2的数据后
                System.out.println(Thread.currentThread().getName() + "说：我拿到了 " + b);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 创建线程2
        new Thread(()->{
            // 2.3 定义交换的数据
            String girl2 = "【杨幂】";
            System.out.println(Thread.currentThread().getName()+"说：我的女友 " + girl2);
            System.out.println(Thread.currentThread().getName()+"说：等待线程1交换数据");
            // 2.4 将数据交换给线程1，并拿到线程1的数据
            try {
                String a = exchanger.exchange(girl2);
                // 成功获取线程1的数据后
                System.out.println(Thread.currentThread().getName()+"说：我拿到了 " + a);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}