Synchronized的前因后果

最新推荐文章于 2022-05-24 19:48:18 发布

lovehello

最新推荐文章于 2022-05-24 19:48:18 发布

阅读量167

点赞数

分类专栏：高并发从零开始

本文链接：https://blog.csdn.net/lovehello/article/details/107291468

版权

高并发从零开始专栏收录该内容

2 篇文章 0 订阅

订阅专栏

为什么要锁

当多个线程要对同一个目标进行修改的时候，为了保证数据的一致性，有序性，所以进行加锁。

通过对一个对象进行加锁，只有一个线程拿到这个对象，才能执行一段代码。

Synchronized的特性

原子性
可见性
- “对一个变量unlock操作之前，必须要同步到主内存中；如果对一个变量进行lock操作，则将会清空工作内存中此变量的值，在执行引擎使用此变量前，需要重新从主内存中load操作或assign操作初始化变量值” 来保证的；
但是不保证有序性

synchronized的基本知识点

synchronized方法的变型

synchronized关键字实际修饰的是一个Object 类，类似于synchronized(Object o), 如果直接修饰synchronized 方法，则等同于

锁的是该类的this对象。

package juc.sync;

public class T1 {
   private int count = 0;
   private static int  count1 = 0;
   private Object obj = new Object();
   public void m() {
	   synchronized(obj) {
		   count++;
		   System.out.println(Thread.currentThread().getName() + "count="+count);
	   }
	   
	   
   }
   public synchronized void m1() {
	     count++;
	     System.out.println("等同于synchronized(this)");
   }
   public synchronized static void m2() {
	   count1++;
	   System.out.println("等同于synchronized(T1.class)");
   }
   public static void main(String[] args) {
	   
   }
   
}

同步方法和非同步方法可否一起调用？

答案是可以，非同步方法没有任何锁，当然这段代码可以被多个线程随时访问。

package juc.sync;
//同步方法和不同步的方法可否一起调用
public class T3 {
 public synchronized void  m1() {
	 try {
		Thread.sleep(200);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	 System.out.println(Thread.currentThread().getName() + "synchronized");
 }
 public void m2() {
	 try {
		Thread.sleep(100);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	 System.out.println(Thread.currentThread().getName() + "not synchronized");
 }
 public static void main(String[] args) {
	 T3 t = new T3();
//	 new Thread(()-> {
//		 t.m1();
//	 }).start();
	 new Thread(t::m1,"t1").start();
//	 new Thread(()-> {
//	 t.m2();
//	 }).start(); 
	 new Thread(t::m2,"t2").start();
	 
 }
}

Synchronized可重入？

可重入的意思是一个同步方法是否可以调用另一个同步方法？可以，因为第一个方法拿的是一个对象锁，到第二方法的时候发现它也是同一把锁的话，是允许调用第二个方法的代码块的。

package juc.sync;

public class T4 {
 synchronized void m1() {
	 try {
		Thread.sleep(100);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	 m2();
	 System.out.println(Thread.currentThread().getName() + "调用完m2");
	 
 }
 synchronized void m2() {
	 try {
		Thread.sleep(200);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	 System.out.println(Thread.currentThread().getName() + "m2 end");
	 
 }
 public static void main(String[] args) {
	 T4 t = new T4();
	 t.m1();
 }
}

该线程发生议程会释放锁
同步队列和等待队列的区别
- 同步队列指得是在runnable的线程，正在准备竞争锁的队列，如果锁被占用了，就会一直在同步队列里
- 等待队列指的是在wait的线程，比如线程正在wait的，sleep的都会放到等待队列，等到被notify或者时间到了，就可以进入同步队列去竞争锁了。