Synchronized之一：基本使用
目录：
Synchronized作用
1、Synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或者代码块。
2、同步的作用不仅仅是互斥，它的另一个作用就是共享可变性，当某个线程修改了可变数据并释放锁后，其它线程可以获取被修改变量的最新值。如果没有正确的同步，这种修改对其它线程是不可见的。
一、Synchronized的基本使用
Synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。Synchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。从语法上讲，Synchronized总共有四种不同的同步块：
1.同步的实例方法（锁用的是其实例对象本身。所有的非静态同步方法执行需要顺序执行，即不能并行执行。）
2.同步的静态方法（锁用的是其类对象本身。所有的静态同步方法执行需要顺序执行，即不能并行执行。）
3.实例方法中的同步块（锁是自己指定的，但不能是引用性对象及null对象）
4.静态方法中的同步块（锁是自己指定的，但不能是引用性对象及null对象）
静态同步方法与非静态同步方法区别：
所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
而所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！
同步块：
而对于同步块，由于其锁是可以选择的，所以只有使用同一把锁的同步块之间才有着竞态条件，这就得具体情况具体分析了，但这里有个需要注意的地方，同步块的锁是可以选择的，但是不是可以任意选择的！！！！这里必须要注意一个物理对象和一个引用对象的实例变量之间的区别！使用一个引用对象的实例变量作为锁并不是一个好的选择，因为同步块在执行过程中可能会改变它的值，其中就包括将其设置为null，而对一个null对象加锁会产生异常，并且对不同的对象加锁也违背了同步的初衷！这看起来是很清楚的，但是一个经常发生的错误就是选用了错误的锁对象，因此必须注意：同步是基于实际对象而不是对象引用的！多个变量可以引用同一个对象，变量也可以改变其值从而指向其他的对象，因此，当选择一个对象锁时，我们要根据实际对象而不是其引用来考虑！作为一个原则，不要选择一个可能会在锁的作用域中改变值的实例变量作为锁对象！
1）执行完同步代码块，就会释放锁。（synchronized）
2）在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放。（exception）
3）在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进入对象的等待池。(wait)
从上面的三点我就可以看到stop方法释放锁是在第二点的，通过抛出异常来释放锁，通过证明，这种方式是不安全的，不可靠的。
接下来我就通过几个例子程序来说明一下这三种使用方式（为了便于比较，三段代码除了Synchronized的使用方式不同以外，其他基本保持一致）。
1.1、没有同步的情况：
package com.dxz.synchronize;
public class SynchronizedTest {
public void method1() {
System.out.println(Thread.currentThread().getName() + " Method 1 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 1 execute");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 1 end");
}
public void method2() {
System.out.println(Thread.currentThread().getName() + " Method 2 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 2 execute");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 2 end");
}
public static void main(String[] args) {
final SynchronizedTest test = new SynchronizedTest();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test.method2();
}
},"thread2").start();
}
}
执行结果如下，线程1和线程2同时进入执行状态，线程2执行速度比线程1快，所以线程2先执行完成，这个过程中线程1和线程2是同时执行的。
thread1 Method 1 start
thread1 Method 1 execute
thread2 Method 2 start
thread2 Method 2 execute
thread2 Method 2 end
thread1 Method 1 end
1.2、对普通方法同步：
package com.dxz.synchronize;
public class SynchronizedTest2 {
public synchronized void method1() {
System.out.println(Thread.currentThread().getName() + " Method 1 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 1 execute");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 1 end");
}
public synchronized void method2() {
System.out.println(Thread.currentThread().getName() + " Method 2 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 2 execute");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 2 end");
}
public void method3() {
System.out.println(Thread.currentThread().getName() + " Method 3 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 3 execute");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 3 end");
}
public static void main(String[] args) {
//test2demo1();
//test2demo2();
test2demo3();
}
private static void test2demo1() {
final SynchronizedTest2 test = new SynchronizedTest2();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test.method2();
}
},"thread2").start();
}
private static void test2demo2() {
final SynchronizedTest2 test = new SynchronizedTest2();
final SynchronizedTest2 test2 = new SynchronizedTest2();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test2.method2();
}
},"thread2").start();
}
private static void test2demo3() {
final SynchronizedTest2 test = new SynchronizedTest2();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test.method3();
}
},"thread2").start();
}
}
test2demo1的执行结果：
thread1 Method 1 start
thread1 Method 1 execute
thread1 Method 1 end
thread2 Method 2 start
thread2 Method 2 execute
thread2 Method 2 end
test2demo2的执行结果：
thread2 Method 2 start
thread2 Method 2 execute
thread1 Method 1 start
thread1 Method 1 execute
thread2 Method 2 end
thread1 Method 1 end
test2demo3的执行结果：
thread1 Method 1 start
thread1 Method 1 execute
thread2 Method 3 start
thread2 Method 3 execute
thread2 Method 3 end
thread1 Method 1 end
2.1、test2demo2测试方法中说明：test和test2属于不同的对象，所以同步互不干扰，线程1和线程2会并行执行。
2.2、通过test2demo1与test2demo3对比说明：同一个类中的所有synchronized修饰的方法是不能同时调用的，也就是说同时只能调用其中一个方法，比如线程1调用method1方法，在method1方法执行完之前，线程2调用method2方法，这个时候线程2就会阻塞，直到线程1调用完method1方法后，线程2才开始执行method2方法。（不仅仅是多个线程调用同一个同步方法）。
2.3、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。
3、静态方法（类）同步
package com.dxz.synchronize;
public class SynchronizedTest3 {
public static synchronized void method1() {
System.out.println(Thread.currentThread().getName() + " Method 1 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 1 execute");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 1 end");
}
public static synchronized void method2() {
System.out.println(Thread.currentThread().getName() + " Method 2 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 2 execute");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 2 end");
}
public synchronized void method3() {
System.out.println(Thread.currentThread().getName() + " Method 2 start");
try {
System.out.println(Thread.currentThread().getName() + " Method 2 execute");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 2 end");
}
public static void main(String[] args) {
//test3demo1();
//test3demo2();
test3demo3();
}
private static void test3demo1() {
final SynchronizedTest3 test = new SynchronizedTest3();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test.method2();
}
},"thread2").start();
}
private static void test3demo2() {
final SynchronizedTest3 test = new SynchronizedTest3();
final SynchronizedTest3 test2 = new SynchronizedTest3();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test2.method2();
}
},"thread2").start();
}
private static void test3demo3() {
final SynchronizedTest3 test = new SynchronizedTest3();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test.method3();
}
},"thread2").start();
}
}
test3demo1执行结果：
thread1 Method 1 start
thread1 Method 1 execute
thread1 Method 1 end
thread2 Method 2 start
thread2 Method 2 execute
thread2 Method 2 end
test3demo2执行结果：
thread1 Method 1 start
thread1 Method 1 execute
thread1 Method 1 end
thread2 Method 2 start
thread2 Method 2 execute
thread2 Method 2 end
test3demo3执行结果：
thread1 Method 1 start
thread1 Method 1 execute
thread2 Method 2 start
thread2 Method 2 execute
thread2 Method 2 end
thread1 Method 1 end
3.1、test3demo1与test3demo2对比：对静态方法的同步本质上是对类的同步（静态方法本质上是属于类的方法，而不是对象上的方法），所以即使test和test2属于不同的对象，但是它们都属于SynchronizedTest类的实例，所以也只能顺序的执行method1和method2，不能并发执行。
3.2、test3demo2与test3demo3对比说明：实例对象上的锁与类对象的锁是两个，所以可以并行的执行method1和method3。
4、代码块同步
package com.dxz.synchronize;
public class SynchronizedTest4 {
public void method1(){
System.out.println(Thread.currentThread().getName() + " Method 1 start");
try {
synchronized (this) {
System.out.println(Thread.currentThread().getName() + " Method 1 execute");
Thread.sleep(3000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 1 end");
}
public void method2(){
System.out.println(Thread.currentThread().getName() + " Method 2 start");
try {
synchronized (this) {
System.out.println(Thread.currentThread().getName() + " Method 2 execute");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " Method 2 end");
}
public static void main(String[] args) {
test4demo1();
}
private static void test4demo1() {
final SynchronizedTest4 test = new SynchronizedTest4();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test.method2();
}
},"thread2").start();
}
private static void test4demo2() {
final SynchronizedTest4 test = new SynchronizedTest4();
final SynchronizedTest4 test2 = new SynchronizedTest4();
new Thread(new Runnable() {
@Override
public void run() {
test.method1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
test2.method2();
}
},"thread2").start();
}
}
test4demo1执行结果：
thread1 Method 1 start
thread1 Method 1 execute
thread2 Method 2 start
thread1 Method 1 end
thread2 Method 2 execute
thread2 Method 2 end
test4demo2执行结果：
thread1 Method 1 start
thread2 Method 2 start
thread2 Method 2 execute
thread1 Method 1 execute
thread2 Method 2 end
thread1 Method 1 end
4.1、虽然线程1和线程2都进入了对应的方法开始执行，但是线程2在进入同步块之前，需要等待线程1中同步块执行完成。
Synchronized之一：基本使用的更多相关文章
- java 多线程 Synchronized方法和方法块 synchronized(this)和synchronized(object)的理解
synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块. 1. synchronized 方法:通过在方法声明中加入 synchronized ...
- 单例模式中用volatile和synchronized来满足双重检查锁机制
背景:我们在实现单例模式的时候往往会忽略掉多线程的情况,就是写的代码在单线程的情况下是没问题的,但是一碰到多个线程的时候,由于代码没写好,就会引发很多问题,而且这些问题都是很隐蔽和很难排查的. 例子1 ...
- Thread 学习记录 <1> -- volatile和synchronized
恐怕比较一下volatile和synchronized的不同是最容易解释清楚的.volatile是变量修饰符,而synchronized则作用于一段代码或方法:看如下三句get代码: int i1; ...
- synchronized使用说明
好久没有更新博客了,今天试着用简单的语言把synchronized的使用说清楚. synchronized是什么? synchronized是用来保证在多线程环境下代码同步执行的可重入的互斥锁.所谓互 ...
- 【Java并发系列04】线程锁synchronized和Lock和volatile和Condition
img { border: solid 1px } 一.前言 多线程怎么防止竞争资源,即防止对同一资源进行并发操作,那就是使用加锁机制.这是Java并发编程中必须要理解的一个知识点.其实使用起来还是比 ...
- (转)Lock和synchronized比较详解
今天看了并发实践这本书的ReentantLock这章,感觉对ReentantLock还是不够熟悉,有许多疑问,所有在网上找了很多文章看了一下,总体说的不够详细,重点和焦点问题没有谈到,但这篇文章相当不 ...
- Synchronized同步性与可见性
Synchronized是具有同步性与可见性的,那么什么是同步性与可见性呢? (1)同步性:同步性就是一个事物要么一起成功,要么一起失败,可谓是有福同享有难同当,就像A有10000去银行转5000给身 ...
- 基于synchronized 或 ReadWriteLock实现 简单缓存机制
package cn.xxx.xxx; import java.util.HashMap; import java.util.Map; import java.util.concurrent.lock ...
- 【Java并发编程实战】-----synchronized
在我们的实际应用当中可能经常会遇到这样一个场景:多个线程读或者.写相同的数据,访问相同的文件等等.对于这种情况如果我们不加以控制,是非常容易导致错误的.在java中,为了解决这个问题,引入临界区概念. ...
- Lock、ReentrantLock、synchronized、ReentrantReadWriteLock使用
先来看一段代码,实现如下打印效果: 1 2 A 3 4 B 5 6 C 7 8 D 9 10 E 11 12 F 13 14 G 15 16 H 17 18 I 19 20 J 21 22 K 23 ...
随机推荐
- Hive的执行生命周期
1.入口$HIVE_HOME/bin/ext/cli.sh 调用org.apache.hadoop.hive.cli.CliDriver类进行初始化过程 处理-e,-f,-h等信息,如果是-h,打印提 ...
- ubuntu 18.04 64bit下如何安装python开发工具jupyterhub
注:这是多用户版本 1.安装依赖 sudo apt-get install npm nodes sudo apt-get install python3-distutils wget https:// ...
- iOS开发进阶 - 富文本正则替换表情
移动端访问不佳,请访问我的个人博客 最近写项目需要用到富文本解析字符串显示表情,下面是我使用正则替换实现富文本的方式,希望能帮助到大家 先上效果图和demo地址 实现过程中需要用到的知识点 NSReg ...
- Can't connect to any repository: xxxxxx Error writing request body to server
今天在git提交代码时一直报如下错误: Can't connect to any repository: https://gitee.com/xxxxxx(https://gitee.com/xxxx ...
- Windows Server 2008驱动安装全攻略
安装设备驱动程序原本是一件非常简单的事情,很多驱动程序在安装的时候我们只要不停单击“下一步”按钮,就能让驱动程序顺利地在对应计算机系统“落户”;不过,当身边的计算机系统升级为Windows Serve ...
- poj 2528 Mayor's posters 线段树+离散化 || hihocode #1079 离散化
Mayor's posters Description The citizens of Bytetown, AB, could not stand that the candidates in the ...
- LeetCode第[84]题(Java)：Largest Rectangle in Histogram（最大的矩形柱状图）
题目:最大的矩形柱状图 难度:hard 题目内容: Given n non-negative integers representing the histogram's bar height wher ...
- git bash 出显错误不能用，怎么解决
解决方法: 好像就是64的会出问题,其实32位的git也可以安装在64位的系统上. 将你64位的git卸掉了后,下载一个32位的git安装,就可以正常使用了, 当然,你的32位的出了错,卸了后也这样处 ...
- mysql数据库优化课程---13、mysql基础操作
mysql数据库优化课程---13.mysql基础操作 一.总结 一句话总结:mysql复制表,索引,视图 1.mysql如何复制表? like select * 1.复制表结构 create tab ...
- IntelliJ IDEA 左侧显示/展开类中的方法
困扰我很久的问题: project直接右键: 打开.关闭对应效果: 之前查到的都是 : 虽然也有类似的功能,但是展开的是右侧窗口中,打开的那个类的: 即使不是我想要的,但也是不错的功能!