文章目录
- synchronized 锁有两种
- synchronized异常捕获
- 主线程和子线程
- volatile的作用
- notify是随机启动等待线程中的一个
synchronized 锁有两种
- 类对象
- 类的实例
第一种：锁类对象，有两种方式，如下：
// 方法一：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)
它有两个功能：
- 线程间的可见性
- 防止指令重排序
注意：
可见性不代表原子性，它只是能够让其他线程能够实时查看到最新值，而其他操作，它不保证。
指令重排序，这个有点深奥，可以先暂时忽略
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();
}
}
}
