synchronized 锁有两种

1. 类对象
2. 类的实例

第一种：锁类对象，有两种方式，如下：

// 方法一：synchronized 修饰static方法
public static synchronized void test(){System.out.println(Thread.currentThread().getName()+" start ");try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" end ");
}
// 方法二：synchronized锁class对象
public void test2(){synchronized (getClass()) {try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" run ");}
}public static void main(String[] args) {TestThread10 t = new TestThread10();new Thread(()->TestThread10.test(),"线程 1 ").start();new Thread(()->t.test2(),"线程 2 ").start();
}

其结果如下：

在线程1，也就是先启动线程1且等线程1走完，才执行线程2；

锁类，就可以理解为，在类对象上加了一把锁，所有加锁的方法都需要等待上一把锁的释放才能执行

第二种：类的实例

只要对同一个实例对象加锁了，才能实现线程同步，如下：

public void test2(){synchronized (this) {try {TimeUnit.SECONDS.sleep(2);} catch (Exception e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" run ");}
}

synchronized异常捕获

使用synchronized的时候，出现异常一定要处理，不然他会自动释放锁
它的机制是手动加锁，自动释放锁。下面看一个例子，在异常的地方一定要处理异常，不然就会想下面代码中的线程1，会被释放掉。

private Integer c = 0;@Override
public void run() {count();
}private synchronized void count(){System.out.println(Thread.currentThread().getName()+" start。。。");while (true) {System.out.println(Thread.currentThread().getName()+" count="+c++);try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}if (c == 5) {int i = 1/0;}}}public static void main(String[] args) {TestThread3 t = new TestThread3();Thread t1 = new Thread(t, "线程 1");Thread t2 = new Thread(t, "线程 2");t1.start();t2.start();
}

主线程和子线程

线程分用户线程和守护线程；

main方法其实是一个主线程，在操作系统启动java.exe后，是开启了一个进程，然后进程启动main线程，main线程有启动其他线程。

• 守护线程：和主线程一起结束（主线程结束，守护线程也结束）
• 用户线程（非守护线程）：但所有的用户线程结束，主线程结束

t2.setDaemon(true);
t2.start();

volatile的作用

可以看这位博主的博客：Java中Volatile关键字详解 - 郑斌blog - 博客园 (cnblogs.com)

它有两个功能：

1. 线程间的可见性
2. 防止指令重排序

注意：

可见性不代表原子性，它只是能够让其他线程能够实时查看到最新值，而其他操作，它不保证。

指令重排序，这个有点深奥，可以先暂时忽略

notify是随机启动等待线程中的一个

notify是随机启动等待线程中的一个，并且跟线程优先级无关，且 wait和notify方法要在同一把lock的情况下使用；还有一点是lock.wait 阻塞还后会把锁让出给需要的线程，然而，在其他线程执行完后，调用lock.notify()，唤醒等待的线程，但是在当前锁里的代码没执行完，不会释放掉锁。

简单场景模拟：

一个固定容量同步容器，拥有put和get方法，以及getCount方法，能够支持两个生产者线程以及10个消费者线程的阻塞调用。

public class TestThread8 {
private final LinkedList list = new LinkedList();private final int MAX = 10;private int count = 0;public synchronized void put(Object o) {while (list.size() == MAX) {try {// 在这里等待；的那个调用notify时会从这里继续执行this.wait();} catch (InterruptedException e) {e.printStackTrace();}}list.add(o);count++;// 启动所有线程，包括生产者，随机的this.notifyAll();
}public synchronized void get() {while (list.size() == 0) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}list.removeLast();count--;this.notifyAll();
}public int getCount() {return list.size();
}public static void main(String[] args) {TestThread8 t = new TestThread8();for (int i = 0; i < 2; i++) {new Thread(() -> {int j = 0;while (true) {t.put(Thread.currentThread().getName() + " put " + t.getCount());System.out.println(Thread.currentThread().getName() + " put " + t.getCount());}}).start();}for (int i = 0; i < 10; i++) {new Thread(() -> {while (true) {t.get();System.out.println(Thread.currentThread().getName() + " get " + t.getCount());}}).start();}
}
}