1.锁的存在,
synchronized锁的对象方法的调用者,谁先拿到锁,谁就执行,当一个线程在执行的时候,里面有等待,但是另一个线程进不来,所以也得等待,所以谁先拿到锁谁先执行
package com.xjmige.lock8; import java.util.concurrent.TimeUnit; //一直都是method1先执行,原因是有锁的存在 public class test1 { public static void main(String[] args) { Entry1 entry1=new Entry1(); new Thread(()->{ entry1.method1(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ entry1.method2(); },"B").start(); } } class Entry1{ //synchronized 锁的对象是方法的调用者 //两个方法是同一个锁,谁先拿到谁执行 public synchronized void method1(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("method1执行了"); } public synchronized void method2(){ System.out.println("method2执行了"); } }
2.method1跟method3执行的话,肯定是method3先执行,method3没有加synchronized,所以不受锁的影响
class Entry2{ //synchronized 锁的对象是方法的调用者 //两个方法是同一个锁,谁先拿到谁执行 public synchronized void method1(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("method1执行了"); } public synchronized void method2(){ System.out.println("method2执行了"); } public void method3(){ System.out.println("method3执行了"); } }
3.当有两个对象的时候,分别调用不同对象的方法,会存在两把锁,所以不会同步,谁执行的速度快谁先执行。
public class test3 { public static void main(String[] args) { Entry3 entry31=new Entry3(); Entry3 entry32=new Entry3(); new Thread(()->{ entry31.method1(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ entry32.method2(); },"B").start(); } } class Entry3{ //synchronized 锁的对象是方法的调用者 //两个方法是同一个锁,谁先拿到谁执行 public synchronized void method1(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("method1执行了"); } public synchronized void method2(){ System.out.println("method2执行了"); } public void method3(){ System.out.println("method3执行了"); } }
4.静态方法在类加载的时候就存在了,所以用static修饰的方法的锁只有一个,锁的是class文件,普通方法锁的就是对象,所以跟第一条一样,谁先获得锁谁先执行,用两个对象分别来执行,结果也是一样。
public class test4 { public static void main(String[] args) { Entry4 entry4=new Entry4(); new Thread(()->{ entry4.method1(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ entry4.method2(); },"B").start(); } } class Entry4{ //synchronized 锁的对象是方法的调用者 //两个方法是同一个锁,谁先拿到谁执行 public static synchronized void method1(){ try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("method1执行了"); } public static synchronized void method2(){ System.out.println("method2执行了"); } }
5.一个static修饰,一个普通方法,同时调用这两个方法,其实这里存在两把锁,一个锁是class的,一个是对象的锁,第一个方法有等待时间,所以method2先执行,无论你用几个对象来执行method1跟method2,都是method2先执行。
public class test5 {
public static void main(String[] args) {
Entry5 entry5=new Entry5();
new Thread(()->{
entry5.method1();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
entry5.method2();
},"B").start();
}
}
class Entry5{
//synchronized 锁的对象是方法的调用者
//两个方法是同一个锁,谁先拿到谁执行
public static synchronized void method1(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("method1执行了");
}
//普通方法,没有static修饰
public synchronized void method2(){
System.out.println("method2执行了");
}
}