• 进入 synchronized 修饰的代码块, 相当于 加锁
• 退出 synchronized 修饰的代码块, 相当于 解锁

        synchronized (this) {sum++;}

        synchronized用的锁是存在于java的对象里头的, 每个对象在存储的时候, 都有一块用来表示当前锁的状态的内存. 如果是无锁状态, 就可以对其进行加锁, 加锁后需要标识已经加了锁, 其他线程要使用, 如果发现已经加锁, 那么就只能阻塞等待.

// 第一次加锁, 加锁成功
lock();
// 第二次加锁, 锁已经被占用, 阻塞等待. 
lock();

按照之前所说的, 加了锁的线程, 再次加锁就会进入阻塞等待, 直到第一次的锁被释放, 但是释放锁的过程也是由这个线程来执行的, 这就产生了矛盾, 也就是无法进行解锁操作, 这个时候就被称之为"死锁"

class TestClass {public int sum;synchronized public void add(){doadd();}synchronized public void doadd() {sum++;}
}
public class Main {public static void main(String[] args) throws InterruptedException {TestClass test = new TestClass();Thread thread1 = new Thread(()-> {for (int i = 0; i < 50000; i++) {test.add();}});Thread thread2 = new Thread(()-> {for (int i = 0; i < 50000; i++) {test.add();}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("the final result: " + test.sum);}
}

public class Test{public synchronized void methond() {}
}

2.修饰静态方法: 锁的Test类的对象

public class Test{public synchronized static void method() {}
}

3.修饰代码块: 明确指出锁哪个对象

public class Test {public void method() {synchronized (this) {// 代码块}}
}

public class Main {public static int flag = 0;public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread(()-> {while(flag == 0) {}System.out.println("Thread1结束!!");});Thread thread2 = new Thread(()->{Scanner in = new Scanner(System.in);System.out.println("输入一个整数");flag = in.nextInt();});thread1.start();thread2.start();}
}

上面的例子中, 使用全局变量flag作为线程1结束的标志判断, 然后再从线程2中去改变这个标志, 让线程1结束,, 但是我们在输入非0数字后, 线程并没有立马结束:

 我们使用java的jdk.jconsole工具来查看这个线程1是否继续在运行:

 可以发现这个Thread-0, 也就是我们的线程1, 并没有结束, 线程1 感受不到线程2对flag进行的修改, 

 public static volatile int flag = 0;

public class Main {public static volatile int flag = 0;public static void main(String[] args) throws InterruptedException {Thread thread1 = new Thread(()-> {while(flag == 0) {}System.out.println("Thread1结束!!");});Thread thread2 = new Thread(()->{Scanner in = new Scanner(System.in);System.out.println("输入一个整数");flag = in.nextInt();});thread1.start();thread2.start();}
}

为什么会产生上面这种问题?

我们来看这个while循环

 load操作从内存读取数据到寄存器, 然后进行compare操作, 此处的cmp操作, load操作的时间开销是远远超过cmp的.

但是此时的编译器就发现, load的开销很大, 同时每次load的结果都是一样, 于是编译器就把这个load操作给又花掉了, 这样子就只执行了第一次load, 后续就只进行cmp操作.

 volatile不保证原子性

class TestClass {volatile public int sum;public void add() {sum++;}
}
public class Main {public static void main(String[] args) throws InterruptedException {TestClass test = new TestClass();Thread thread1 = new Thread(()-> {for (int i = 0; i < 50000; i++) {test.add();}});Thread thread2 = new Thread(()-> {for (int i = 0; i < 50000; i++) {test.add();}});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("the final result: " + test.sum);}
}

volatile不能保证其原子性 

import java.util.Scanner;class TestClass {public int sum;public void add() {sum++;}
}
public class Main {public static void main(String[] args) throws InterruptedException {TestClass test = new TestClass();Thread thread1 = new Thread(()-> {while(true) {synchronized (test) {if (test.sum != 0) {break;}}}});Thread thread2 = new Thread(()-> {Scanner in = new Scanner(System.in);test.sum = in.nextInt();});thread1.start();thread2.start();thread1.join();thread2.join();System.out.println("the final result: " + test.sum);}
}

 wait和notify

import java.util.Scanner;public class Main {public static void main(String[] args) throws InterruptedException {Object object = new Object();System.out.println("wait之前!");object.wait();System.out.println("wait之后 !!");}
}

运行发现抛出异常(无效锁状态异常):

 我们需要配合synchronized使用:

import java.util.Scanner;public class Main {public static void main(String[] args) throws InterruptedException {Object object = new Object();System.out.println("wait之前!");synchronized (object) {object.wait();}System.out.println("wait之后 !!");}
}

结果才是正确的:

 加锁的对象必须和wait的对象是同一个, 同时notify也要放在synchronized中使用.

但是我们也不能让他一直这样等待下去, 我们应该在需要唤醒他的时候来唤醒它.

wait(Long time)

wait还有一个传入参数版本的, 可以指定等待的时候, 如果时间过了就自动结束等待:

import java.util.Scanner;public class Main {public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread thread1 = new Thread(()->{while (true) {System.out.println("wait start!");synchronized (locker) {try {locker.wait(3000);} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("wait ended !");}});thread1.start();}
}

notify() / notifyAll()

• 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。
• 如果有多个线程等待，则有线程调度器随机挑选出一个呈 wait 状态的线程。(并没有 "先来后到")
• 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行 完，也就是退出同步代码块之后才会释放对象锁。

import java.util.Scanner;public class Main {public static void main(String[] args) throws InterruptedException {Object locker = new Object();Thread thread1 = new Thread(()->{while (true) {System.out.println("wait start!");synchronized (locker) {try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}System.out.println("wait ended !");}});thread1.start();Thread.sleep(1000);// 必须要先wait, 才能notify才有效果, 如果还没有wait就notify, 此时wait就唤不醒,但是不会出现异常Thread thread2 = new Thread(()->{synchronized (locker) {System.out.println("this is notify start!!");locker.notify();System.out.println("this is notify ended !");}});thread2.start();}
}

运行结果:

 注意: 如果此时有三个线程thread1, thread2, thread3中都调用了object.wait, 此时如果在main方法中调用一个object.notify(), 会随机唤醒这三个线程中的一个, 另外两个仍然是wait状态, 如果调用了object.notifyAll, 此时就会把三个线程都唤醒. 然后这三个线程就会同时竞争锁,然后随机调度.

wait和sleep的对比

wait带有一个有时间参数版本的, 可以自动唤醒,  这个时候就感觉和sleep差不多.

但是他们最大的区别在于根本的用法, 或者是说设计这个东西是用来干嘛的, 是不一样的. 

• wait是解决线程之间的控制顺序, 而sleep是单纯的让线程休眠一会!
• 实现上也是有区别的: wait需要搭配锁来使用, 必须拿到锁之后才能wait, 而sleep不需要