参考文献： java synchronized详解
- synchronized 修饰方法
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
- 修饰代码块
synchronized (object) {
waitThread.start();
try {
System.out.print("主线程等待\n");
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
获得的锁是传入的 类的实例中的锁
有如下一个例子：
public class Main {
private static dog object = new dog();
public static void main(String[] args) {
System.out.print("主线程运行\n");
WaitThread waitThread = new WaitThread();
//waitThread.start();
synchronized (object) {
waitThread.start(); //注意此处放的地方
try {
System.out.print("主线程等待\n");
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print("主线程结束\n");
}
static class WaitThread extends Thread {
@Override
public void run() {
try {
synchronized (object) {
Thread.sleep(3000);
System.out.print("主线程唤起\n");
object.notifyAll();
}
} catch (Exception e) {
}
}
}
}
结果：
主线程运行
主线程等待
（sleep3秒）
主线程唤起
主线程结束
Process finished with exit code 0
请注意上述例子中的waitThread.start(); 执行的地方，是放在了synchronized(Objedt) {} 块中；如果将此代码放到它的外边也就是注释掉的地方，就会有问题：
主线程运行
（sleep3秒）
主线程唤起
主线程等待
因为在执行 run方法时已经持有了object 的锁，主线程中的synchronized 的实例object锁 已经被持有了，所以不能执行，等子线程中的锁释放之后主线程才可以执行
注意点：wait() , notify() ,notifyAll() ,必须放在synchronized block 中，否则会抛异常。也就是说它们都是线程不安全的。
在做测试的时候每次wait()之后的nofity()时线程在争夺同一把锁的时候是随机的，谁抢到就给谁。
notifyAll() 让我想起了在做驱动时的一种惊群效应，一旦锁被释放了，所有的wait线程被唤醒。
对于对象obj来说：
obj.wait()：该方法的调用，使得调用该方法的执行线程（T1）放弃obj的对象锁并阻塞，直到别的线程调用了obj的notifyAll方法、或者别的线程调用了obj的notify方法且JVM选择唤醒（T1），被唤醒的线程（T1）依旧阻塞在wait方法中，与其它的线程一起争夺obj的对象锁，直到它再次获得了obj的对象锁之后，才能从wait方法中返回。（除了notify方法，wait还有带有时间参数的版本，在等待了超过所设时间之后，T1线程一样会被唤醒，进入到争夺obj对象锁的行列；另外中断可以直接跳出wait方法）
obj.notify()：该方法的调用，会从所有正在等待obj对象锁的线程中，唤醒其中的一个（选择算法依赖于不同实现），被唤醒的线程此时加入到了obj对象锁的争夺之中，然而该notify方法的执行线程此时并未释放obj的对象锁，而是离开synchronized代码块时释放。因此在notify方法之后，synchronized代码块结束之前，所有其他被唤醒的，等待obj对象锁的线程依旧被阻塞。
obj.notifyAll()：与notify的区别是，该方法会唤醒所有正在等待obj对象锁的线程。（不过同一时刻，也只有一个线程可以拥有obj的对象锁）
另Thread.join() : 阻塞当前调用join函数时所在的线程，直到接受线程执行完毕之后再继续，有点类似wait，但是这个是Thread调用，阻塞当前调用线程的，并直到执行的线程执行完毕之后才不阻塞当前线程
Thread.yeid() :使该函数的线程让出CPU固定的时间。主动让出线程的执行权给其他线程。因为让的的线程有可能被线程调度程序再次选中，所以有可能没有效果（亲测确实如此），谨慎使用。
public static void main(String[] args) {
Mrunable1 thread1 = new Mrunable1("A\n");
Mrunable1 thread2 = new Mrunable1("B\n");
thread1.start();
thread2.start();
}
static class Mrunable1 extends Thread {
public Mrunable1(String name) {
super(name);
}
@Override
public synchronized void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print(Thread.currentThread().getName());
Thread.yield();
}
}
