从此不怕Synchronized锁
- Synchronized的使用
Synchronized是通过监视器保证线程同步从而保证线程安全。但是Synchronized锁可以锁对象和锁类，并会产生不同的效果，通过下面的案例彻底理解Synchronized锁的使用方式。
即：
对于普通的同步方法，锁是当前实例对象
对于静态同步方法，锁是该类
对于同步方法块，锁是Synchronized括号里面配置的对象。
下面通过代码具体分析几种情况。要想了解并发情况，首先我们必须知道，类信息、实例对象分别存放在什么位置。类的信息，包括静态变量都是存放在方法区中；而实例对象，包括类的成员变量，是存放在堆中。
1. 成员变量+普通同步方法+锁
public class SynDemo implements Runnable {
private int sum = 0;
@Override
public void run() {
add();
}
public synchronized void add() {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sync01.sum);
System.out.println(new SynDemo().sum);
}
}
result:
2000
0
public class SynDemo implements Runnable {
private int sum = 0;
@Override
public void run() {
add();
}
public synchronized void add() {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sync01.sum);
System.out.println(sync02.sum);
}
}
result:
1000
1000
0
分析：
理解了这两个demo再去理解同步代码块下的多线程安全问题，将会达到事半功倍的效果。上面两个demo主要是想表达，成员变量和类的实例化对象一样，都是在堆中创建，每次new对象，都会在堆中产生一个新的对象。所以第一个demo中，当在线程同步的情况下，两个线程去操作同一个对象，最后的结果是2000；而第二个demo中，两个线程去操作两个实例化对象，所以每个对象的成员变量sum为1000。因此我们也可以发现，其实在第一个demo中才会有线程安全问题，在第二个demo中是不存在线程安全问题的，有疑问可以去掉锁验证一下。通过这个例子也可以去理解为什么sping中多例是线程安全的。
2. 成员变量+同步代码块+对象锁
public class SynDemo implements Runnable {
private int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (this) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sync01.sum);
System.out.println(new SynDemo().sum);
}
}
result:
2000
0
public class SynDemo implements Runnable {
private int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (this) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sync01.sum);
System.out.println(sync02.sum);
System.out.println(new SynDemo().sum);
}
}
result:
1000
1000
0
分析：
同案例1一样，Demo1为两个线程执行一个实例化对象，但是加了Synchronized对象锁，因此实现了同步，保证线程安全。Demo2为两个线程执行两个实例化对象，各自利用各自的成员变量sum，因此不会产生并发安全问题。
3. 成员变量+同步代码块+类锁
public class SynDemo implements Runnable {
private int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (SynDemo.class) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sync01.sum);
System.out.println(new SynDemo().sum);
}
}
result:
2000
0
public class SynDemo implements Runnable {
private int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (SynDemo.class) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sync01.sum);
System.out.println(sync02.sum);
System.out.println(new SynDemo().sum);
}
}
result:
1000
1000
0
分析：
Demo1为两个线程执行一个实例化对象，会产生并发安全问题，但是加了同步类锁(可以理解为锁的级别比对象锁更高)，当然也可以实现并发同步，保证线程安全。而Demo2同样实例化两个对象，各自操作各自的成员变量sum，也不会产生线程安全问题。
4. 静态变量+普通方法+锁
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
private synchronized void add() {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
result:
2000
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
private synchronized void add() {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
输出结果不确定(存在线程安全问题)
分析：
从案例4我们要注意，由成员变量换成静态变量，而上面已经讲过，静态变量存放在方法区中，所有实例化对象共享一份。再看Demo1,两个线程执行同一个实例化对象，然后添加的是对象锁，因此该对象锁能锁住该实例化对象，实现同步，保证线程安全。
Demo2是两个线程执行两个实例化对象，添加的是对象锁，相当于各自的对象锁锁住各自的对象，而静态变量是类变量，存放在方法区中而不是堆中，此情况对象锁并不能保证线程同步，因此会产生线程安全问题。
5. 静态变量+静态方法+锁
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
static synchronized void add() {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
result:
2000
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
static synchronized void add() {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
result:
2000
分析：
该案例相比案例4，锁由对象锁换成类锁，对于Demo1,两个线程操作一个对象，毫无疑问会使其同步。而Demo2,两个线程执行两个实例化对象，由于使用的是类锁，也会使线程同步，保证线程安全。
6. 静态变量+同步代码块+对象锁
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (this) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
result:
2000
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (this) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
输出结果不确定(存在线程安全问题)
分析：该案例和案例4一样，添加对象锁，只能保证同一对象的并发同步，不能保证不同对象同步。
7. 静态变量+同步代码块+类锁
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (SynDemo.class) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync01);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
result:
2000
public class SynDemo implements Runnable {
private static int sum = 0;
@Override
public void run() {
add();
}
private void add() {
synchronized (SynDemo.class) {
for (int i = 0; i < 1000; i++) {
sum++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynDemo sync01 = new SynDemo();
SynDemo sync02 = new SynDemo();
Thread thread1 = new Thread(sync01);
Thread thread2 = new Thread(sync02);
thread1.start();
thread2.start();
thread1.join(); //等待线程执行完
thread2.join(); //等待线程执行完
System.out.println(sum);
}
}
result:
2000
分析：
该案例同案例5一样，添加类锁，无论是多个线程操作一个实例化对象还是多个实例化对象，都能保证线程安全。
总结：
对象锁只能保证各自实例化对象并发的线程安全问题。类锁可以保证多个实例化多谢的安全问题。
从此不怕Synchronized锁的更多相关文章
- synchronized锁重入
package synLockIn_1; /* synchronized锁重入,当一个线程得到一个对象锁且还未释放锁时,再次请求此对象锁时可以再次得到该对象的锁 * 此例中线程1进入Service类的 ...
- Java多线程4：synchronized锁机制
脏读 一个常见的概念.在多线程中,难免会出现在多个线程中对同一个对象的实例变量进行并发访问的情况,如果不做正确的同步处理,那么产生的后果就是"脏读",也就是取到的数据其实是被更改过 ...
- synchronized锁自旋
http://www.jianshu.com/p/5dbb07c8d5d5 原理 通常说的synchronized在方法或块上加锁,这里的锁就是对象锁(当然也可以在类上面),或者叫重量锁,在JVM中又 ...
- 记一次synchronized锁字符串引发的坑兼再谈Java字符串
问题描述 业务有一个需求,我把问题描述一下: 通过代理IP访问国外某网站N,每个IP对应一个固定的网站N的COOKIE,COOKIE有失效时间.并发下,取IP是有一定策略的,取到IP之后拿IP对应的C ...
- 记一次 synchronized 锁字符串引发的坑兼再谈 Java 字符串
业务有一个需求,我把问题描述一下: 通过代理IP访问国外某网站N,每个IP对应一个固定的网站N的COOKIE,COOKIE有失效时间. 并发下,取IP是有一定策略的,取到IP之后拿IP对应的COOKI ...
- Synchronized锁在Spring事务管理下，为啥还线程不安全？
前言 只有光头才能变强. 文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y 大年初二,朋友问了我一个技术的问题(朋友实在是好学, ...
- Synchronized锁性能优化偏向锁轻量级锁升级 多线程中篇（五）
不止一次的提到过,synchronized是Java内置的机制,是JVM层面的,而Lock则是接口,是JDK层面的 尽管最初synchronized的性能效率比较差,但是随着版本的升级,synchro ...
- 多线程之Synchronized锁的基本介绍
基本介绍 synchronized是Java实现同步的一种机制,它属于Java中关键字,是一种jvm级别的锁.synchronized锁的创建和释放是此关键字控制的代码的开始和结束位置,锁是有jvm控 ...
- Java多线程6：Synchronized锁代码块（this和任意对象）
一.Synchronized(this)锁代码块 用关键字synchronized修饰方法在有些情况下是有弊端的,若是执行该方法所需的时间比较长,线程1执行该方法的时候,线程2就必须等待.这种情况下就 ...
随机推荐
- 因为 MongoDB 没入门，我丢了一份实习工作
有时候不得不感慨一下,系统升级真的是好处多多,不仅让我有机会重构了之前的烂代码,也满足了我积极好学的虚荣心.你看,Redis 入门了.Elasticsearch 入门了,这次又要入门 MongoDB, ...
- （三）linux三剑客之sed
一.sed是什么? 二.sed的工作原理? 三.sed的基本用法? 四.sed的进阶使用? 一.sed是什么? sed 就是一个非交互式流编译器: 交互式:文件缓存.人工编译.全局并行可逆 非交互式: ...
- 源码分析（4）-ConcurrentHashMap（JDK1.8）
一.UML类图 ConcurrentHashMap键值不能为null:底层数据结构是数组+链表/红黑二叉树:采用CAS(比较并交换)和synchronized来保证并发安全. CAS文章:https: ...
- Java线程变量问题-ThreadLocal
关于Java线程问题,在博客上看到一篇文章挺好的: https://blog.csdn.net/w172087242/article/details/83375022#23_ThreadLocal_1 ...
- multimap遍历与查找
std::multimap<int, std::string> m; m.insert(std::make_pair(0, "w0")); m.insert(std:: ...
- 【Java Spring Cloud 实战之路】添加一个SpringBootAdmin监控
0. 前言 在之前的几章中,我们先搭建了一个项目骨架,又搭建了一个使用nacos的gateway网关项目,网关项目中并没有配置太多的东西.现在我们就接着搭建在Spring Cloud 微服务中另一个重 ...
- Java线程池简聊
在Java中,已经实现了4中内置的线程池,这四种我不多聊. 大家各种网站论坛都能查得到. 现在说一下这四种线程池的基类: ThreadPoolExecutor在ThreadPoolExecutor中你 ...
- mysql中的四种常用的引擎
MySQL常用的引擎有:InnoDB存储引擎.MyISAM存储引擎.MEMORY存储引擎.Archive存储引擎 InnoDB存储引擎 InnoDB是事务型数据库的首选引擎,支持事务安全表(ACID) ...
- 【从单体架构到分布式架构】（三）请求增多，单点变集群(2)：Nginx
上一个章节,我们学习了负载均衡的理论知识,那么是不是把应用部署多套,前面挂一个负载均衡的软件或硬件就可以应对高并发了?其实还有很多问题需要考虑.比如: 1. 当一台服务器挂掉,请求如何转发到其他正常的 ...
- Install Centos7 on VirtualBox in mac
Step 1:准备虚拟机及镜像 下载合适的Virtual Box版本 官方下载链接:https://www.virtualbox.org/wiki/Downloads 这里选择的版本是:https:/ ...