synchronized用法简单梳理
线程安全是并发编程中的重要关注点，应该注意到的是，形成线程安全问题的主要诱因有两点java
- 一是存在共享数据(也称临界资源)
- 二是存在多条线程共同操做共享数据
所以为了解决这个问题，咱们可能须要这样一个方案，当存在多个线程操做共享数据时，须要保证同一时刻有且只有一个线程在操做共享数据，其余线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其余线程只能处于等待的状态，直到当前线程处理完毕释放该锁。
在 Java 中，关键字 synchronized 能够保证在同一个时刻，只有一个线程能够执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操做)，同时咱们还应该注意到synchronized另一个重要的做用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其余线程所看到（保证可见性，彻底能够替代Volatile功能），这点确实也是很重要的。编程
synchronized的三种应用方式
synchronized关键字最主要有如下3种应用方式，下面分别介绍安全
- 修饰实例方法，做用于当前实例加锁，进入同步代码前要得到 当前实例 的锁
- 修饰静态方法，做用于当前类对象加锁，进入同步代码前要得到 当前类对象 的锁
- 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要得到 给定对象 的锁。
synchronized做用于实例方法
所谓的实例对象锁就是用synchronized修饰实例对象中的实例方法，注意是实例方法不包括静态方法并发
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
public class AccountingSync2 implements Runnable {
//共享资源(临界资源)
static int i = 0;
/**
* synchronized 修饰实例方法
*/
synchronized void getI() {
if (i % 1000000 == 0) {
print(i);
}
}
public synchronized void increase() {
i++;
getI();
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(i);
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
AccountingSync2 accountingSync2 = new AccountingSync2();
exec.execute(accountingSync2);
exec.execute(accountingSync2);
exec.shutdown();
}
}
最后的结果为：
1000000
1519541
2000000
2000000
- 上述代码中，咱们开启两个线程操做同一个共享资源即变量i，因为i++操做并不具有原子性，该操做是先读取值，而后写回一个新值，至关于原来的值加上1，分两步完成，若是第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一块儿看到同一个值，并执行相同值的加1操做，这也就形成了线程安全失败，所以对于increase方法必须使用synchronized修饰，以便保证线程安全。
- 此时注意到synchronized修饰的是实例方法increase，在这样的状况下，当前线程的锁即是实例对象instance，注意Java中的线程同步锁能够是任意对象。
- 当一个线程正在访问一个对象的 synchronized 实例方法，那么其余线程不能访问该对象的其余 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁以后，其余线程没法获取该对象的锁，因此没法访问该对象的其余synchronized实例方法，可是其余线程仍是能够访问该实例对象的其余非synchronized方法，可是一个 synchronized 方法能够调用另外一个须要得到一样锁的synchronized方法，由于已经获取了锁。
- 若是是一个线程 A 须要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1)，另外一个线程 B 须要访问实例对象 obj2 的 synchronized 方法f2(当前对象锁是obj2)，这样是容许的，由于两个实例对象锁并不一样相同，此时若是两个线程操做数据并不是共享的，线程安全是有保障的，遗憾的是若是两个线程操做的是共享数据，那么线程安全就有可能没法保证了。
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
public class AccountingSync2 implements Runnable {
//共享资源(临界资源)
static int i = 0;
/**
* synchronized 修饰实例方法
*/
synchronized void getI() {
if (i % 1000000 == 0) {
print(i);
}
}
public synchronized void increase() {
i++;
getI();
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(i);
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
AccountingSync2 accountingSync2 = new AccountingSync2();
exec.execute(accountingSync2);
exec.execute(new AccountingSync2());
exec.shutdown();
}
}
#输出结果：
1000000
1249050
1329218
- 上述代码与前面不一样的是咱们同时建立了两个新实例AccountingSync2，而后启动两个不一样的线程对共享变量i进行操做，但很遗憾操做结果是1329218而不是指望结果2000000。
- 虽然咱们使用synchronized修饰了increase方法，但却new了两个不一样的实例对象，这也就意味着存在着两个不一样的实例对象锁，所以两个进程都会进入各自持有对象的对象锁，也就是说两个线程使用的是不一样的锁，所以线程安全是没法保证的。
- 解决这种困境的的方式是将synchronized做用于静态的increase方法，这样的话，对象锁就当前类对象，因为不管建立多少个实例对象，但对于的类对象拥有只有一个，全部在这样的状况下对象锁就是惟一的。下面咱们看看如何使用将synchronized做用于静态的increase方法。
synchronized做用于静态方法
当synchronized做用于静态方法时，其锁就是当前类的class对象锁。因为静态成员不专属于任何一个实例对象，是类成员，所以经过class对象锁能够控制静态成员的并发操做。须要注意的是若是一个线程A调用一个实例对象的非static synchronized 方法，而线程B须要调用这个实例对象所属类的静态 synchronized方法，是容许的，不会发生互斥现象，由于访问静态 synchronized 方法占用的锁是当前类的 class 对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。ide
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
class OtherTask implements Runnable{
AccountingSyncClass accounting = new AccountingSyncClass();
@Override
public void run(){
for (int j = 0; j < 1000000; j++) {
accounting.increaseForObject();
}
print(accounting.getI());
}
}
public class AccountingSyncClass implements Runnable {
//共享资源(临界资源)
private static int i = 0;
/**
* synchronized 修饰实例方法
*/
public synchronized void increaseForObject() {
i++;
}
public synchronized static void increase() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(i);
}
public int getI(){
return i;
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new AccountingSyncClass());
exec.execute(new AccountingSyncClass());
exec.execute(new OtherTask()); // 1
exec.shutdown();
}
}
输出结果为：
1459696
2692181
2754098
注释掉代码中的 1 那一行代码的输出结果为：
1468495
2000000
- 因为synchronized关键字修饰的是静态increase方法，与修饰实例方法不一样的是，其锁对象是当前类的class对象。
- 注意代码中的increase4Obj方法是实例方法，其对象锁是当前实例对象，若是别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不一样，但咱们应该意识到这种状况下可能会发现线程安全问题(操做了共享静态变量i)。
- 所以在设计同步代码的时候必定要仔细思考到底该用 多大的同步粒度 和 该对什么对象 使用同步操做。
synchronized同步代码块
除了使用关键字修饰实例方法和静态方法外，还可使用同步代码块，在某些状况下，咱们编写的方法体可能比较大，同时存在一些比较耗时的操做，而须要同步的代码又只有一小部分，若是直接对整个方法进行同步操做，可能会得不偿失，此时咱们可使用同步代码块的方式对须要同步的代码进行包裹，这样就无需对整个方法进行同步操做了。this
public class AccountingSync implements Runnable{
static AccountingSync instance=new AccountingSync();
static int i=0;
@Override
public void run() {
//省略其余耗时操做....
//使用同步代码块对变量i进行同步操做,锁对象为instance
synchronized(instance){
for(int j=0;j<1000000;j++){
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(instance);
Thread t2=new Thread(instance);
t1.start();t2.start();
t1.join();t2.join();
System.out.println(i);
}
}
- 从代码看出，将synchronized做用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁。
- 若是当前有其余线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++操做。
- 固然除了instance做为对象外，咱们还可使用this对象(表明当前实例)或者当前类的class对象做为锁。
//this,当前实例对象锁
synchronized(this){
for(int j=0;j<1000000;j++){
i++;
}
}
//class对象锁
synchronized(AccountingSync.class){
for(int j=0;j<1000000;j++){
i++;
}
}
同步方法最好运用在 共享资源 内部而不是使用它的外部
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
class OtherTask implements Runnable{
AccountingSyncClass accounting = new AccountingSyncClass();
@Override
public void run(){
for (int j = 0; j < 1000000; j++) {
accounting.increaseForObject();
}
print(accounting.getAdapterInteger());
}
}
class AdapterInteger {
private int i = 0;
public synchronized void increase(){
++i;
}
public synchronized int getI(){
return i;
}
}
public class AccountingSyncClass implements Runnable {
//共享资源(临界资源)
private static AdapterInteger adapterInteger = new AdapterInteger();
/**
* synchronized 修饰实例方法
*/
public synchronized void increaseForObject() {
adapterInteger.increase();
}
public synchronized static void increase() {
adapterInteger.increase();
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(getAdapterInteger());
}
public static int getAdapterInteger() {
return adapterInteger.getI();
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new AccountingSyncClass());
exec.execute(new AccountingSyncClass());
exec.execute(new OtherTask());
exec.shutdown();
}
}
#输出结果为
1183139
2688189
3000000
这样三个线程中的任务的锁都是咱们的共享变量 adapterInteger 对象的锁，这样就能够完成真正的同步，无论哪一个线程都是得到了 adapterInteger 对象的锁才能运行相应的代码。线程
相关文章
- 1. 简单算法梳理2
- 2. FCN简单梳理
- 3. SpringCache简单梳理
- 4. AVS2简单梳理
- 5. 机器学习：算法简单梳理
- 6. Java中Synchronized的用法（简单介绍）
- 7. Java简单知识梳理
- 8. Spring MVC 简单梳理
- 9. Android Mvp简单梳理
- 10. UDP知识简单梳理
- 更多相关文章...
- • Thymeleaf简单格式化输出 - Thymeleaf 教程
- • ASP 表单和用户输入 - ASP 教程
- • Git可视化极简易教程 — Git GUI使用方法
- • Github 简明教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 简单算法梳理2
- 2. FCN简单梳理
- 3. SpringCache简单梳理
- 4. AVS2简单梳理
- 5. 机器学习：算法简单梳理
- 6. Java中Synchronized的用法（简单介绍）
- 7. Java简单知识梳理
- 8. Spring MVC 简单梳理
- 9. Android Mvp简单梳理
- 10. UDP知识简单梳理