详解synchronized关键字
线程    

详解synchronized关键字

64 次访问
leon
Scroll Down

详解synchronized关键字

synchronized关键字

关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要多个线程在同一时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

synchronized表现形式

  • 对于普通同步方法，锁是当前实例对象。被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
  • 对于静态同步方法，锁是当前类的Class对象。其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
  • 对于同步方法块，其作用的范围是大括号{}括起来的代码，锁是Synchronized括号里配置的对象。
  • 对于一个类，起作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。

修饰一个代码块

一个线程访问一个一个对象中synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。

DEMO1

public class SyncThread implements Runnable {
    public static int count;
    public SyncThread() {
        count = 0;
    }
    @Override
    public void run() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public int getCount() {
        return count;
    }
}

SyncThread调用：

        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();

结果：

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

当两个并发线程（thread1和thread2）访问同一个对象(syncThread)中的sunchronized代码块时，在同一时刻只有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和Thread2是互斥的，因为在执行synchronized代码块是会锁定当前对象，只有执行完该代码块才能释放该对象锁。下一个线程才能执行并锁定该对象。
将SyncThread主函数更改如下：

Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
thread1.start();
thread2.start();

结果如下：

SyncThread1:0
SyncThread2:1
SyncThread1:2
SyncThread2:3
SyncThread1:4
SyncThread2:5
SyncThread1:6
SyncThread2:7
SyncThread1:8
SyncThread2:9

不是说一个线程执行synchronized代码块时其它的线程受阻塞吗？为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联，而上面的代码等同于下面这段代码：

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

这时创建了两个SyncThread的对象syncThread1和syncThread2，线程thread1执行的是syncThread1对象中的synchronized代码(run)，而线程thread2执行的是syncThread2对象中的synchronized代码(run)；我们知道synchronized锁定的是对象，这时会有两把锁分别锁定syncThread1对象和syncThread2对象，而这两把锁是互不干扰的，不形成互斥，所以两个线程可以同时执行。

当一个线程访问对象的一个sunchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。

public class Counter implements Runnable {
    private int count;

    public Counter() {
        this.count = 0;
    }

    public void countAdd() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void printCount() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println(Thread.currentThread().getName() + " count:" + count);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.equals("A")) {
            countAdd();
        } else if (threadName.equals("B")) {
            printCount();
        }
    }
}

调用代码：

Counter counter = new Counter();
Thread thread1 = new Thread(counter, "A");
Thread thread2 = new Thread(counter, "B");
thread1.start();
thread2.start();

结果：

A:0
B count:1
A:1
B count:2
B count:2
A:2
B count:4
A:3
B count:4
A:4

上面代码中countAdd是一个synchronized的，printCount是非synchronized的。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

指定给某个对象加锁

package synchromized;

/**
 * @ClassName : Account
 * @Description : 给指定对象加锁
 * @Author : LiuXinyu
 * @Site : www.imlxy.cn
 * @Date: 2020-04-11 20:53
 */
public class Account {
    String name;
    float amount;

    public Account(String name, float amount) {
        this.name = name;
        this.amount = amount;
    }

    //存钱
    public void deposit(float amt) {
        amount += amt;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void withdraw(float amt) {
        amount -= amt;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public float getBalance() {
        return amount;
    }
}

class AccountOperator implements Runnable{

    private Account account;

    public AccountOperator(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        synchronized (account) {
            account.deposit(500);
            account.withdraw(500);
            System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
        }
    }
}

调用代码：

Account account = new Account("zs", 10000.0f);
AccountOperator accountOperator = new AccountOperator(account);
final int THREAD_NUM = 5;
Thread[] threads = new Thread[THREAD_NUM];
for (int i = 0; i < THREAD_NUM; i++) {
    threads[i] = new Thread(accountOperator, "Thread" + i);
    threads[i].start();
}

输出结果：

Thread0:10000.0
Thread4:10000.0
Thread3:10000.0
Thread2:10000.0
Thread1:10000.0

在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。
当有一个明确的对象作为锁时，就可以用类似下面这样的方式写程序

public void method3(SomeObject obj)
{
   //obj 锁定的对象
   synchronized(obj)
   {
      // todo
   }
}

当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁：

class Test implements Runnable {
    private byte[] lock = new byte[0];  // 特殊的instance变量
    public void method() {
        synchronized (lock) {
            // todo 同步代码块
        }
    }
    @Override
    public void run() {
    }
}

修饰一个方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){//todo}; synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。如将DEMO1的run方法改成如下的方式，实现的效果一样。

public synchronized void run() {
   for (int i = 0; i < 5; i ++) {
      try {
         System.out.println(Thread.currentThread().getName() + ":" + (count++));
         Thread.sleep(100);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
}

Synchronized作用于整个方法的写法。
写法一：

public synchronized void method() {
    // todo
}

写法二：

public void method() {
    synchronized (this) {
        // todo
    }
}

在用synchronized修饰方法时要注意以下几点：

  1. synchronized关键字不能继承。
    虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：
    在子类方法中加上synchronized关键字
class Parent {
    public synchronized void method() {
    }
}

class Child extends Parent {
    public synchronized void method() {
    }
}

在子类方法中调用父类的同步方法

class Parent {
    public synchronized void method() {
    }
}

class Child extends Parent {
    public void method() {
        super.method();
    }
}
  1. 在定义接口方法时不能使用synchronized关键字。
  2. 构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。

修饰静态方法

Synchronized也可修饰一个静态方法，用法如下：

public synchronized static void method() {
   // todo
}

静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。我们对Demo1进行一些修改如下：

Demo5

class SyncThread implements Runnable {
    private static int count;
    public SyncThread() {
        count = 0;
    }
    public synchronized static void method() {
        for (int i = 0; i < 5; i++) {
            try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public synchronized void run() {
        method();
    }
}

调用代码：

SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();

结果：

SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

yncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。这与Demo1是不同的。

修饰一个类

class ClassName {
   public void method() {
      synchronized(ClassName.class) {
         // todo
      }
   }
}

把Demo5再作一些修改。
Demo6修饰一个类

class SyncThread implements Runnable {
    private static int count;

    public SyncThread() {
        count = 0;
    }

    public static void method() {
        synchronized (SyncThread.class) {
            for (int i = 0; i < 5; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ":" + (count++));
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public synchronized void run() {
        method();
    }
}

其效果和Demo5是一样的，synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁。

总结：

  • 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
  • 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
  • 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

本文转载自原文：http://blog.csdn.net/luoweifu/article/details/46613015

© 本文著作权归作者所有，转载前请务必署名

最新文章
spring常用注解

此文章介绍我们日常开发当中常用的spring注解！
集合Collection解析(一)

Java集合类存放在java.util包中，是一个用来存放对象的容器。
Java线程池

线程池的基本思想是一种对象池，在程序启动时就开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。
HashMap源码解析

HashMap采用key/value存储结构，每个key对应唯一的value，查询和修改的速度都很快，能达到O(1)的平均时间复杂度。它是非线程安全的，且不保证元素存储的顺序
从尾到头打印链表

剑指Offer06：从尾到头打印链表题目题目链接剑指Offer06：从尾到头打印链表题目描述输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
分类
Spring Boot springboot
Spring spring
源码 源码
集合 集合
J.U.C juc
多线程 thread
Java基础 java基础
设计模式 designpattern
Jpa jpa
教程 教程
剑指Offer algorithm1
JDK8新特性 jdk8新特性
Java java
数据结构与算法 Algorithm
标签
注解 注解
set set
list list
并发 并发
线程池 线程池
源码 源码
HashMap hashmap
集合 集合
递归 递归
线程 线程
单例模式 单例模式
sql sql
css css
哀悼· 哀悼
位运算 位运算
链表 链表
线性表 线性表
栈 栈
队列 队列
字符串 字符串
数组 数组
动态规划 动态规划
斐波那契 fibonacci
Lambda lambda
方法引用 方法引用
Stream stream
函数式接口 函数式接口
静态方法、默认方法 静态方法默认方法
二叉树 binarytree