synchronized使用和原理全解

最新推荐文章于 2023-09-22 22:45:17 发布

兔老大RabbitMQ

最新推荐文章于 2023-09-22 22:45:17 发布

阅读量3.4w

点赞数 301

分类专栏： Java

本文链接：https://blog.csdn.net/hebtu666/article/details/103057476

版权

Java 专栏收录该内容

65 篇文章 200 订阅

订阅专栏

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

修饰一个方法

被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

修饰一个静态的方法

其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

修饰一个代码块

被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

修饰一个类

其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

修饰一个方法

被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

如果多个线程访问同一个对象的实例变量，可能出现非线程安全问题。

例子：a线程set后sleep2000ms，看b线程是否可以趁机set，造成非线程安全

HasSelfPrivateNum.java:

package service;

public class HasSelfPrivateNum {

	private int num = 0;

	public void addI(String username) {
		try {
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

package extthread;

import service.HasSelfPrivateNum;

public class ThreadA extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadA(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("a");
	}

}

package extthread;

import service.HasSelfPrivateNum;

public class ThreadB extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadB(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("b");
	}

}

run：

package test;

import service.HasSelfPrivateNum;
import extthread.ThreadA;
import extthread.ThreadB;

public class Run {
	public static void main(String[] args) {

		HasSelfPrivateNum numRef = new HasSelfPrivateNum();

		ThreadA athread = new ThreadA(numRef);
		athread.start();

		ThreadB bthread = new ThreadB(numRef);
		bthread.start();

	}
}

结果：a线程set后sleep2000ms，b线程可以趁机set，造成非线程安全

这时我们使用synchronized修饰addI方法：

package service;

public class HasSelfPrivateNum {

	private int num = 0;

	synchronized public void addI(String username) {
		try {
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

结果：B不能set了，说明线程安全。

注意：我们取得的是对象锁，也就是说，一个对象一个锁，而不是锁住整个类或者代码或者方法。

例子：两个对象两个锁

myobject.java

打印名字后sleep，最后打印end

package extobject;

public class MyObject {

	synchronized public void methodA() {
		try {
			System.out.println("begin methodA threadName="
					+ Thread.currentThread().getName());
			Thread.sleep(5000);
			System.out.println("end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

package extthread;

import extobject.MyObject;

public class ThreadA extends Thread {

	private MyObject object;

	public ThreadA(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.methodA();
	}

}

package extthread;

import extobject.MyObject;

public class ThreadB extends Thread {

	private MyObject object;

	public ThreadB(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.methodA();
	}
}

RUN:

package test.run;

import extobject.MyObject;
import extthread.ThreadA;
import extthread.ThreadB;

public class Run {

	public static void main(String[] args) {
		MyObject object = new MyObject();
		ThreadA a = new ThreadA(object);
		a.setName("A");
		ThreadB b = new ThreadB(object);
		b.setName("B");

		a.start();
		b.start();
	}

}

结果：两个对象互不影响，各自运行各自上锁

其它方法被调用是什么效果呢？

之前做实验是因为怕大家不理解知识，现在大家已经有了一定的基础，这个结论不再做实验。

结论：

如果A线程持有x对象的锁，B线程不可调用synchronized修饰的方法，但是可以异步调用没有被synchronized修饰的方法

synchronized具有锁重入功能，也就是说一个线程获得锁，再次请求是可以再次得到对象的锁的

下面做实验验证这个结论：

service.java

package myservice;

public class Service {

	synchronized public void service1() {
		System.out.println("service1");
		service2();
	}

	synchronized public void service2() {
		System.out.println("service2");
		service3();
	}

	synchronized public void service3() {
		System.out.println("service3");
	}

}

thread:

package extthread;

import myservice.Service;

public class MyThread extends Thread {
	@Override
	public void run() {
		Service service = new Service();
		service.service1();
	}

}

run:

package test;

import extthread.MyThread;

public class Run {
	public static void main(String[] args) {
		MyThread t = new MyThread();
		t.start();
	}
}

结果验证了上面的结论：

注：在父子类之间同样适用，不再做实验

但是如果一个线程出现了异常，难道就永远锁住了资源吗？其实不是的，出现异常自动释放锁。

实验：让a锁住对象后出现异常，看b是否可以拿到锁，代码不再展示。

结果：b可以正常执行。

修饰一个静态的方法

其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

也就是说整个类就一个锁，这也和静态的概念相符（静态方法和属性是属于类的而不是具体一个对象的）

让我们来验证这个结论：

service：

package service;

public class Service {

	synchronized public static void printA() {
		try {
			System.out.println("线程名称为：" + Thread.currentThread().getName()
					+ "在" + System.currentTimeMillis() + "进入printA");
			Thread.sleep(3000);
			System.out.println("线程名称为：" + Thread.currentThread().getName()
					+ "在" + System.currentTimeMillis() + "离开printA");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	synchronized public static void printB() {
		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
				+ System.currentTimeMillis() + "进入printB");
		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
				+ System.currentTimeMillis() + "离开printB");
	}

}

a：

package extthread;

import service.Service;

public class ThreadA extends Thread {
	private Service service;

	public ThreadA(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.printA();
	}
}

b：

package extthread;

import service.Service;

public class ThreadB extends Thread {
	private Service service;

	public ThreadB(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.printB();
	}
}

run：

package test;

import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;

public class Run {

	public static void main(String[] args) {

		Service service1 = new Service();
		Service service2 = new Service();

		ThreadA a = new ThreadA(service1);
		a.setName("A");
		a.start();

		ThreadB b = new ThreadB(service2);
		b.setName("B");
		b.start();

	}

}

结果：

但是，请注意一个显而易见的结论：a线程访问synchronized修饰的静态方法时，b线程可以访问synchronized修饰的非静态方法，原因也很容易想到：静态方法是属于类的，普通方法是属于对象本身的，所以一个是对象锁，一个是class锁，不会影响。

为了验证这个结论，我们做实验看看结果。

service：

AB为静态的，C普通的。

package service;

public class Service {

	synchronized public static void printA() {
		try {
			System.out.println("线程名称为：" + Thread.currentThread().getName()
					+ "在" + System.currentTimeMillis() + "进入printA");
			Thread.sleep(3000);
			System.out.println("线程名称为：" + Thread.currentThread().getName()
					+ "在" + System.currentTimeMillis() + "离开printA");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	synchronized public static void printB() {
		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
				+ System.currentTimeMillis() + "进入printB");
		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
				+ System.currentTimeMillis() + "离开printB");
	}

	synchronized public void printC() {
		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
				+ System.currentTimeMillis() + "进入printC");
		System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
				+ System.currentTimeMillis() + "离开printC");
	}

}

a：

package extthread;

import service.Service;

public class ThreadA extends Thread {
	private Service service;

	public ThreadA(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.printA();
	}

}

b：

package extthread;

import service.Service;

public class ThreadB extends Thread {
	private Service service;

	public ThreadB(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.printB();
	}
}

c：

package extthread;

import service.Service;

public class ThreadC extends Thread {

	private Service service;

	public ThreadC(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.printC();
	}
}

run：

package test;

import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;
import extthread.ThreadC;

public class Run {

	public static void main(String[] args) {

		Service service = new Service();

		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();

		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();

		ThreadC c = new ThreadC(service);
		c.setName("C");
		c.start();

	}

}

结果：

说明：验证了结论，因为AB同步执行，C异步执行。

修饰一个代码块

被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；（而不一定是本对象了）

（synchronized方法是对当前对象加锁，synchronized代码块是对某个对象加锁）

用synchronized声明方法是有弊端的，比如A调用同步方法执行一个很长时间的任务，这时B就必须等待，有时候这种长时间等待是低效率且没有必要的，这时我们就要认识一下synchronized同步代码块了。

格式是这样的：synchronized(类名){......}

我们先来认识第一种用法来体会修饰代码块的好处：

synchronized(this)同步代码块：a调用相关代码后，b对其它synchronized方法和synchronized(this)同步代码块调用会阻塞。但是没有被synchronized修饰的代码就得以执行，不像之前修饰方法那么死板了。

我们来看一个例子：

第一个循环异步，第二个循环同步：

package mytask;

public class Task {

	public void doLongTimeTask() {
		for (int i = 0; i < 100; i++) {
			System.out.println("nosynchronized threadName="
					+ Thread.currentThread().getName() + " i=" + (i + 1));
		}
		System.out.println("");
		synchronized (this) {
			for (int i = 0; i < 100; i++) {
				System.out.println("synchronized threadName="
						+ Thread.currentThread().getName() + " i=" + (i + 1));
			}
		}

	}
}

thread1：

package mythread;

import mytask.Task;

public class MyThread1 extends Thread {

	private Task task;

	public MyThread1(Task task) {
		super();
		this.task = task;
	}

	@Override
	public void run() {
		super.run();
		task.doLongTimeTask();
	}

}

thread2：

package mythread;

import mytask.Task;

public class MyThread2 extends Thread {

	private Task task;

	public MyThread2(Task task) {
		super();
		this.task = task;
	}

	@Override
	public void run() {
		super.run();
		task.doLongTimeTask();
	}

}

run：

package test;

import mytask.Task;
import mythread.MyThread1;
import mythread.MyThread2;

public class Run {

	public static void main(String[] args) {
		Task task = new Task();

		MyThread1 thread1 = new MyThread1(task);
		thread1.start();

		MyThread2 thread2 = new MyThread2(task);
		thread2.start();
	}
}

结果：

在非同步代码块时，是交叉打印的

同步代码块时排队执行：

另一个用法：

synchronized(非this)同步代码块（也就是说将任意对象作为对象监视器）：

格式：synchronized(非this对象x){......}

1、当多个线程持有的对象监听器为同一个对象时，依旧是同步的，同一时间只有一个可以访问，

2、但是对象不同，执行就是异步的。

这样有什么好处呢？

（因为如果一个类有很多synchronized方法或synchronized（this）代码块，还是会影响效率，这时用synchronized(非this)同步代码块就不会和其它锁this同步方法争抢this锁）

实验

第一点我们就不验证了，因为体现不出它的好处，我们验证第二点：

service：

一个同步非this代码块，一个同步方法：

package service;

public class Service {

	private String anyString = new String();

	public void a() {
		try {
			synchronized (anyString) {
				System.out.println("a begin");
				Thread.sleep(3000);
				System.out.println("a   end");
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	synchronized public void b() {
		System.out.println("b begin");
		System.out.println("b   end");
	}

}

a：

package extthread;

import service.Service;

public class ThreadA extends Thread {
	private Service service;

	public ThreadA(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.a();

	}

}

b：

package extthread;

import service.Service;

public class ThreadB extends Thread {

	private Service service;

	public ThreadB(Service service) {
		super();
		this.service = service;
	}

	@Override
	public void run() {
		service.b();

	}

}

run：

package test;

import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;

public class Run {

	public static void main(String[] args) {
		Service service = new Service();

		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();

		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();

	}

}

结果：

确实是异步的。

最后一个要注意的点：我们知道synchronized(非this对象x){......}是将对象x监视，这也就意味着当线程a调用这段代码时，线程b调用类x中的同步方法和代码块也会是同步的效果（阻塞）。

为了让大家更明白，做最后一个例子：

首先创建一个有静态方法的类：

package test2.extobject;

public class MyObject {
	synchronized public void speedPrintString() {
		System.out.println("speedPrintString ____getLock time="
				+ System.currentTimeMillis() + " run ThreadName="
				+ Thread.currentThread().getName());
		System.out.println("-----------------");
		System.out.println("speedPrintString releaseLock time="
				+ System.currentTimeMillis() + " run ThreadName="
				+ Thread.currentThread().getName());
	}
}

然后用 synchronized(非this对象x){......}的形式引用它，并进入这个代码块，然后看看这时这个静态方法是否可以被调用。

service：作用是synchronized(object)

package test2.service;

import test2.extobject.MyObject;

public class Service {

	public void testMethod1(MyObject object) {
		synchronized (object) {
			try {
				System.out.println("testMethod1 ____getLock time="
						+ System.currentTimeMillis() + " run ThreadName="
						+ Thread.currentThread().getName());
				Thread.sleep(5000);
				System.out.println("testMethod1 releaseLock time="
						+ System.currentTimeMillis() + " run ThreadName="
						+ Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

threadA：

package test2.extthread;

import test2.extobject.MyObject;
import test2.service.Service;

public class ThreadA extends Thread {

	private Service service;
	private MyObject object;

	public ThreadA(Service service, MyObject object) {
		super();
		this.service = service;
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		service.testMethod1(object);
	}

}

threadB：

package test2.extthread;

import test2.extobject.MyObject;

public class ThreadB extends Thread {
	private MyObject object;

	public ThreadB(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.speedPrintString();
	}
}

run：

package test2.run;

import test2.extobject.MyObject;
import test2.extthread.ThreadA;
import test2.extthread.ThreadB;
import test2.service.Service;

public class Run {

	public static void main(String[] args) throws InterruptedException {
		Service service = new Service();
		MyObject object = new MyObject();

		ThreadA a = new ThreadA(service, object);
		a.setName("a");
		a.start();

		Thread.sleep(100);

		ThreadB b = new ThreadB(object);
		b.setName("b");
		b.start();
	}

}

结果：

是同步的。

当然，把修饰方法改为修饰代码块也是一样不能被执行的。

Synchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。

synchronized底层原理

在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统来实现，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高。

在 Java 6 之后从 JVM 层面对synchronized 较大优化，锁的实现引入了如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令。

其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。

当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。但是原理其实都是类似的。具体的实现是操作系统的知识可以去翻我操作系统的文章。

锁详解

锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

自旋：当有个线程A去请求某个锁的时候，这个锁正在被其它线程占用，但是线程A并不会马上进入阻塞状态，而是循环请求锁(自旋)。这样做的目的是因为很多时候持有锁的线程会很快释放锁的，线程A可以尝试一直请求锁，没必要被挂起放弃CPU时间片，因为线程被挂起然后到唤醒这个过程开销很大,当然如果线程A自旋指定的时间还没有获得锁，仍然会被挂起。

自适应性自旋：自适应性自旋是自旋的升级、优化，自旋的时间不再固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态决定。例如线程如果自旋成功了，那么下次自旋的次数会增多，因为JVM认为既然上次成功了，那么这次自旋也很有可能成功，那么它会允许自旋的次数更多。

锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。

偏向锁的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那么偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不用做了。偏向锁默认是开启的，也可以关闭。

兔老大RabbitMQ

关注

301
点赞
踩
599

收藏

觉得还不错? 一键收藏
打赏
194
评论
synchronized使用和原理全解

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：修饰一个方法被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；修饰一个静态的方法其作用的范围是整个静态方法，作用的对象是这个类的所有对象；修饰一个代码块被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；修...
复制链接

扫一扫