线程同步知识点+案例（子线程父线程交替执行，输出10遍我爱你）

4. 关于java多线程同步锁问题        线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。同步和锁定    1、锁的原理
(1):Java中每个对象都有一个内置锁。
(2):当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。
(3):当程序运行到synchronized同步方法或代码块时该对象锁才起作用。
(4):一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。
(5):释放锁是指持锁线程退出了synchronized同步方法或代码块。
关于锁和同步，有一下几个要点：1）、只能同步方法，而不能同步变量和类；2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。6）、线程睡眠时，它所持的任何锁都不会释放。7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。
静态方法同步:
要同步静态方法，需要一个用于整个类对象的锁，这个对象就是这个类（XXX.class)。
四、如果线程不能获得锁会怎么样
如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。
当考虑阻塞时，一定要注意哪个对象正被用于锁定：1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。2、调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。
五、何时需要同步
在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。
对于非静态字段中可更改的数据，通常使用非静态方法访问。对于静态字段中可更改的数据，通常使用静态方法访问。
如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。已经超出SJCP考试范围了。
六、线程安全类
当一个类已经很好的同步以保护它的数据时，这个类就称为“线程安全的”。
即使是线程安全类，也应该特别小心，因为操作的线程是间仍然不一定安全。
七、线程同步小结
1、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。4、对于同步，要时刻清醒在哪个对象上同步，这是关键。5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。

package cn.happy1.test1;public class Rannable implements Runnable{Object name;Object after;Object befor;public Rannable(Object name, Object after, Object befor) {super();this.name = name;this.after = after;this.befor = befor;}@Overridepublic void run() {int count=10;while(count>0){synchronized (after) {synchronized (befor) {count--;try {System.out.print(name);befor.notify();} catch (Exception e) {e.printStackTrace();}}try {after.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}

package cn.happy1.test1;public class WaitNotify {public static void main(String[] args) throws Exception {Object I=new Object();Object love=new Object();Object you=new Object();Thread t1=new Thread(new Rannable("我", you, I));Thread t2=new Thread(new Rannable("爱", I, love));Thread t3=new Thread(new Rannable("你", love, you));t1.start();Thread.sleep(200);t2.start();Thread.sleep(200);t3.start();}}

子线程  父线程 交替执行

package cn.happy1.test2;public class Rannable1{private boolean flag=true;public synchronized void work1(int c){if(!flag){try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}} for (int i = 0; i <5; i++) {System.out.println("子线程");}flag=false;this.notify();}public synchronized void main1(int c){if(flag){try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}for (int i = 0; i <5; i++) {System.out.println("父线程");}flag=true;this.notify();}}

package cn.happy1.test2;public class Test {public static void main(String[] args) throws Exception {new Test().work();}public void work(){final Rannable1 rs = new Rannable1();new Thread(new Runnable() {public void run() {for (int i = 1; i <= 3; i++) {rs.work1(i);}}}).start();for (int i = 1; i <= 3; i++) {rs.main1(i);}}}