11、JUC--线程八锁
线程八锁
• 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用
其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻
内，只能有唯一一个线程去访问这些synchronized方法
• 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的
synchronized方法
• 加个普通方法后发现和同步锁无关
• 换成两个对象后，不是同一把锁了，情况立刻变化。
• 都换成静态同步方法后，情况又变化
• 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实
例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获
取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实
例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非
静态同步方法释放锁就可以获取他们自己的锁。
• 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对
象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个
静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取
锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同
步方法之间，只要它们同一个类的实例对象！
题目判打印的是one还是two？
1、
class Number{ public synchronized void getOne(){ System.out.println("one"); } public synchronized void getTwo(){ System.out.println("two"); } }
测试：
public static void main(String[] args) { Number num = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num.getTwo(); } }).start(); }
两个普通同部方法，两个线程标准打印
2、
新增方法让getOne方法让其睡眠三秒
class Number{ public synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("one"); } public synchronized void getTwo(){ System.out.println("two"); } }
新增Thread.sleep()方法给getOne()
此时得到结果的顺序：
3、
新增一个普通方法
class Number{ public synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("one"); } public synchronized void getTwo(){ System.out.println("two"); } public void getThree(){ System.out.println("Three"); } }
测试类：
Number num = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num.getTwo(); } }).start(); new Thread(new Runnable() { @Override public void run() { num.getThree(); } }).start();
4、
两个普通同部方法，两个Number对象
class Number{ public synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("one"); } public synchronized void getTwo(){ System.out.println("two"); } public void getThree(){ System.out.println("Three"); } }
Number num = new Number(); Number num1 = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num1.getTwo(); } }).start();
5、
修改getOne()为静态同部方法
class Number{ public static synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("one"); } public synchronized void getTwo(){ System.out.println("two"); } public void getThree(){ System.out.println("Three"); } }
Number num = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num.getTwo(); } }).start();
6、
修改两个方法均为静态同部方法
class Number{ public static synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("one"); } public static synchronized void getTwo(){ System.out.println("two"); }
}
Number num = new Number(); //Number num1 = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num.getTwo(); } }).start();
7、
一个静态同部方法
一个非静态同部方法
两个对象
class Number{ public static synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("one"); } public synchronized void getTwo(){ System.out.println("two"); } public void getThree(){ System.out.println("Three"); } }
Number num = new Number(); Number num1 = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num1.getTwo(); } }).start();
8、
两个静态同部方法
两个对象
class Number{ public static synchronized void getOne(){ try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("one"); } public static synchronized void getTwo(){ System.out.println("two"); } }
Number num = new Number(); Number num1 = new Number(); new Thread(new Runnable() { @Override public void run() { num.getOne(); } }).start(); new Thread(new Runnable() { @Override public void run() { num1.getTwo(); } }).start();
线程八锁的关键：
1、非静态方法的锁默认为this，静态方法的锁为对应的Class实例
2、在某一个时刻内，只能有一个线程持有锁，无论几个线程
