synchronized的四种用法

最新推荐文章于 2024-06-19 09:50:23 发布
最新推荐文章于 2024-06-19 09:50:23 发布
阅读量4.6k 收藏 35
点赞数 7
原文链接：https://www.cnblogs.com/lukelook/p/9946065.html
版权

一 修饰方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。

例如：
方法一

//Synchronized修饰方法时，锁住的是对象实例，如果是不同的对象实例，则锁不住
public synchronized void test_sync() throws InterruptedException {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
         System.out.println(Thread.currentThread().getName()+"-进入synchronized修饰方法-"+df.format(new Date()));
         Thread.sleep(5000);
}

方法二：

//定义方法体,锁住的是对象实例，如果是不同的对象实例，则锁不住
public void test_sync_code() throws InterruptedException {
         synchronized (this){
             SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
             System.out.println(Thread.currentThread().getName()+"-进入synchronize代码块-"+df.format(new Date()));
             Thread.sleep(5000);
         }
}

写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。

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代码块来进行同步。

二 修饰一个代码块
1）一个线程访问一个对象中的synchronized(this)同步代码块或方法时，其他试图访问该对象的线程将被阻塞。

Demo:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

/**
 * @Author: thunder
 * @Date: 2020/7/26 11:22
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestSynchronized  {

    @Test
    public void test() throws InterruptedException {

        //自定义线程池
        ExecutorService executorService  =  new ThreadPoolExecutor(10,20,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<>(10));
        //定义线程计数器的初始数量，每一个线程完成，调用downLatch.countDown()减1
        CountDownLatch latch             =  new CountDownLatch(2);

        //创建TestData对象
        TestData testdata   = new TestData();
         //TestData testdata1  = new TestData();
        //TestData testdata2  = new TestData();

        //创建线程实例
        TestMythead t1  = new TestMythead("Thread-1",latch,testdata);
        TestMythead t2  = new TestMythead("Thread-2",latch,testdata);

        //提交任务到线程池
        executorService.execute(t1);
        executorService.execute(t2);
        //线程等待，唤醒主线程，继续执行
        latch.await();
        //关闭线程池,释放资源
        executorService.shutdown();
        System.out.println(Thread.currentThread().getName()+"-hello,我又回来了");
    }

}


class TestMythead implements Runnable{

    private Thread t;
    private String threadName;
    private CountDownLatch downLatch;//线程计数器
    private final TestData testData;

    //构造方法
    TestMythead(String name,CountDownLatch downLatch,TestData data){
        this.threadName = name;
        this.downLatch  = downLatch;
        this.testData   = data;
    }

    //定义线程体
    @Override
    public void run() {

           System.out.println(Thread.currentThread().getName()+"-正在执行...");
            try {
                this.testData.test_sync();
            } catch (InterruptedException e) 
                e.printStackTrace();
            }
            //完成任务计数器减1
            this.downLatch.countDown();
    }

    //直接实现runable接口需要同时定义run()和start(),才能执行
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this,threadName);
            t.start ();
        }
    }

}

//定义别的线程
class TestMythead2 extends Thread{

    private String threadName;
    private CountDownLatch downLatch;//线程计数器
    private TestData testData;

    //构造方法
    TestMythead2(String name,CountDownLatch downLatch,TestData data){
        this.threadName = name;
        this.downLatch  = downLatch;
        this.testData   = data;
    }

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName()+"-正在执行...");

        try {
              //可以并发访问没有Synchronized修饰的方法
              testData.test_no_sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //完成任务计数器减1
        this.downLatch.countDown();
    }

}


 class TestData{

     //Synchronized修饰方法时，锁住的是对象实例，如果是不同的对象实例，则锁不住
     public synchronized void test_sync() throws InterruptedException {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
         System.out.println(Thread.currentThread().getName()+"-进入synchronized修饰方法-"+df.format(new Date()));
         Thread.sleep(5000);
     }

     //定义方法体,锁住的是对象实例，如果是不同的对象实例，则锁不住
     public void test_sync_code() throws InterruptedException {
         synchronized (this){
             SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
             System.out.println(Thread.currentThread().getName()+"-进入synchronize代码块-"+df.format(new Date()));
             Thread.sleep(5000);
         }
     }

     //定义Synchronized修饰静态方法时，锁住的是class实例，class实例都会被锁住
     public synchronized static void test_sync_static() throws InterruptedException {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
         System.out.println(Thread.currentThread().getName()+"-进入synchronized修饰的静态方法-"+df.format(new Date()));
         Thread.sleep(5000);
     }

     //定义没有Synchronized修饰的方法,别的线程可以访问该对象的非synchronized代码块而不受阻塞
     public void test_no_sync() throws InterruptedException {
         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
         System.out.println(Thread.currentThread().getName()+"-进入没有synchronized修饰的方法-"+df.format(new Date()));
         Thread.sleep(5000);
     }

 }

注意下面两个程序的区别：

初始化线程，使用相同对象，锁住对象，线程阻塞

// TestSynchronized类中test()方法创建线程实例
TestData testdata   = new TestData();
TestMythead t1  = new TestMythead("Thread-1",latch,testdata);
TestMythead t2  = new TestMythead("Thread-2",latch,testdata);

在这里插入图片描述
初始化线程，使用不同对象，线程并行执行，未进入阻塞状态:

// TestSynchronized类中test()方法创建线程实例
TestData testdata1  = new TestData();
TestData testdata2  = new TestData();
//创建线程实例
TestMythead t1  = new TestMythead("Thread-1",latch,testdata);
TestMythead t2  = new TestMythead("Thread-2",latch,testdata);

在这里插入图片描述

总结：synchronized作用于方法时，锁住的是对象的实例(this)。

2）一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestSynchronized  {

    @Test
    public void test() throws InterruptedException {

        //自定义线程池
        ExecutorService executorService  =  new ThreadPoolExecutor(10,20,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<>(10));
        //定义线程计数器的初始数量，每一个线程完成，调用downLatch.countDown()减1
        CountDownLatch latch             =  new CountDownLatch(3);

        TestData testdata   = new TestData();
        //TestData testdata1  = new TestData();
        //TestData testdata2  = new TestData();

        //创建线程实例
        TestMythead t1  = new TestMythead("Thread-1",latch,testdata);
        TestMythead t2  = new TestMythead("Thread-2",latch,testdata);
        //创建其他线程
        TestMythead2 t3 = new TestMythead2("Thread-3",latch,testdata);
        //提交任务到线程池
        executorService.execute(t1);
        executorService.execute(t2);
        executorService.execute(t3);
        //线程等待，唤醒主线程，继续执行
        latch.await();
        //关闭线程池,释放资源
        executorService.shutdown();
        System.out.println(Thread.currentThread().getName()+"-hello,我又回来了");
    }

}

在这里插入图片描述
可以看到定义的其他线程，可以并发访问同一对象非synchronized修饰的代码。

3）指定要给某个对象加锁

class TestMythead implements Runnable{

    private Thread t;
    private String threadName;
    private CountDownLatch downLatch;//线程计数器
    private final TestData testData;

    //构造方法
    TestMythead(String name,CountDownLatch downLatch,TestData data){
        this.threadName = name;
        this.downLatch  = downLatch;
        this.testData   = data;
    }

    //定义线程体
    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName()+"-正在执行...");

        //synchronized 作用于一个对象实例时，锁住的是**所有以该对象为锁的代码块**。如果其他代码块，没有以该对象为锁，则可以访问该对象的非synchronized 方法。
        synchronized (testData){

            System.out.println(Thread.currentThread().getName()+"-进入了修饰的代码块~");

            try {
              
                testData.test_no_sync();
                //this.testData.test_sync();
                //this.testData.test_sync_code();
                //TestData.test_sync_static();//class实例直接调用静态方法
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //完成任务计数器减1
            this.downLatch.countDown();

        }


    }

    //直接实现runable接口需要同时定义run()和start(),才能执行
    public void start () {
        System.out.println("Starting " +  threadName );
        if (t == null) {
            t = new Thread (this,threadName);
            t.start ();
        }
    }

}



//定义别的线程
class TestMythead2 extends Thread{

    private String threadName;
    private CountDownLatch downLatch;//线程计数器
    private TestData testData;

    //构造方法
    TestMythead2(String name,CountDownLatch downLatch,TestData data){
        this.threadName = name;
        this.downLatch  = downLatch;
        this.testData   = data;
    }

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName()+"-正在执行...");
        //未以此对象为锁时，可以访问对象的非synchronized方法，已此对象为锁时，线程进入了阻塞状态
        //synchronized (TestData.class) {
            try {
                //可以并发访问没有Synchronized修饰的方法
                //testData.test_sync();
                testData.test_no_sync();
                //TestData.test_sync_static();//class实例直接调用静态方法
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //完成任务计数器减1
            this.downLatch.countDown();
       // }

    }

}

执行TestSynchronized.test()方法
其他线程未加对象锁时：
在这里插入图片描述
其他线程加对象锁时，锁住的是所有以该对象为锁的代码块，对应线程进入了阻塞状态：
在这里插入图片描述

synchronized 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。如果其他代码块，没有以该对象为锁，则可以访问该对象的非synchronized 方法。

三、修饰一个静态的方法

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

静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

/**
 * 同步线程
 */
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();
   }
}
 
public class Demo00{
    
    public static void main(String args[]){
        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和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。

四 、修饰一个类

Synchronized还可作用于一个类，用法如下：

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

/**
 * 同步线程
 */
class SyncThread implements Runnable {
   
   private static int count;
 
   public SyncThread() {
      count = 0;
   }
 
   public static void method() {
      //synchronized 作用于一个class实例时，锁住的是所有以该class实例为锁的代码块，如果其他线程未使用class实例锁，则可以访问synchronized方法，
      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();
   }
}

本例的的给class加锁和上例的给静态方法加锁是一样的，是所有对象公用一把锁。

但是synchronized 作用于一个class实例时，锁住的是所有以该class实例为锁的代码块，如果其他线程未使用class实例锁，则可以访问此class实例的非synchronized方法。

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

Synchronized 作用范围

  1. 作用于方法时，锁住的是对象的实例(this)；
  2. 当作用于静态方法时，锁住的是Class实例，又因为Class的相关数据存储在永久带PermGen
    （jdk1.8 则是 metaspace），永久带是全局共享的，因此静态方法锁相当于类的一个全局锁，
    会锁所有调用该方法的线程；
  3. synchronized 作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。
  4. synchronized 作用于一个class实例时，锁住的是所有以该class为锁的代码块。
thunder-1
关注
  • 7
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronized用法详解
ganmaotong的博客
06-01 1万+
目录1.线程安全问题2.使用同步机制管理共享数据3.synchronized原理概述3.1 同步代码块的实现原理3.2 同步方法的原理4.synchronized的使用4.1同步代码块 4.2同步普通方法4.3同步静态方法5.synchronized的不可中断性与可重入性5.1 不可中断性5.2 可重入性6.使用synchronized的注意事项6.1注意synchronized同步块的粒度 6.2 对 String 加锁 6.3 对Integer、Long、Short等包装类加锁 线程允许程
Java中synchronized正确使用方法解析
08-25
四、synchronized 的使用方法 synchronized 的使用方法可以分为两种，一种是使用 synchronized 关键字修饰方法，另一种是使用 synchronized 代码块。例如，在使用 synchronized void addOne() 方法时，可以使用 ...
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
关键字: synchronized详解
最新发布
qq_63353796的博客
06-19 882
在C程序代码中我们可以利用操作系统提供的互斥锁来实现同步块的互斥访问及线程的阻塞及唤醒等工作。在Java中除了提供Lock API外还在语法层面上提供了synchronized关键字来实现互斥同步原语, 本文将对synchronized关键字详细分析。
Synchronized 有几种用法？
KHOST的博客
12-13 722
我们都知道 Synchronized 是线程安全同步用的，大部分程序可能只会用到同步方法上面。其实 Synchronized 可以用到更多的场合，栈长列举了以下几个用法。 1、同步普通方法 这个也是我们用得最多的，只要涉及线程安全，上来就给方法来个同步锁。这种方法使用虽然最简单，但是只能作用在单例上面，如果不是单例，同步方法锁将失效。 /**  * 用在普通方法  */ private s...
synchronized 的用法
晓游的专栏
06-02 1233
synchronized 是java中的关键字，同步锁，用于解决多线程安全问题。 有以下几种用法一. 修饰一个代码块， 被修饰的代码块称为同步语句块，其同步的作用范围是大括号{}括起来的代码块，锁住的对象由synchronized 后面的小括号里的内容决定。锁会有同步代码块执行完成时释放.     小括号里的内容有以下几种场景  a、synchronized(this) { 同步代码块 }    ...
Java 中 synchronized的用法详解(四种用法)
09-03
下面将详细介绍 `synchronized` 的四种主要用法。 1. **修饰实例方法**： 当 `synchronized` 修饰一个实例方法时，它会锁定当前对象的监视器，即所谓的“成员锁”。这意味着同一时间只有一个线程可以执行该方法。...
java里面synchronized用法.doc
05-09
四、synchronized 关键字的使用示例 以下是一个简单的示例代码，演示了 synchronized 关键字的使用： ```java public class TxtThread implements Runnable { int num = 100; String str = new String(); ...
synchronized的几种示例
10-24
本文将深入探讨`synchronized`的几种使用示例，包括方法加锁、代码块加锁（针对`this`和对象）以及静态方法加锁。 1. **方法加锁** 当在实例方法前使用`synchronized`关键字时，它会锁定当前对象的监视器，只有...
java synchronized关键字的用法
09-02
- 避免过多使用静态 synchronized 方法，因为这可能导致大量线程竞争同一把锁，降低系统效率。 - 考虑使用 Lock 接口提供的更细粒度的锁控制，如 ReentrantLock，它可以提供尝试获取锁、可中断锁等待以及定时锁等待...
Synchronized的用法
菜鸟教程
01-29 1881
Java中Synchronized的用法（简单介绍） </h1> <div class="clear"></div> <div class="postBody"> 简单介绍 synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：  　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；&
synchronized的用法
Y1230601的博客
08-03 489
synchronized的几种用法 synchronized关键字最主要有以下5种应用方式，下面分别介绍。 修饰对象普通方法，作用于当前对象，进入同步方法前要获得当前对象的锁 修饰对象静态方法，作用于当前类对象加锁，进入同步该方法前要获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得指定对象的锁。 修饰 this，指定当前对象，对给当前对象加锁，进入同步代...
synchronized 关键字（Android）
oizz01的专栏
11-22 764
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：  　　public synchronized void accessVal(int newVal);  　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行
Synchronized用法
hustzw07的博客
05-12 1860
synchronized 我们知道，synchronized可以用来修饰一个方法或者一个代码块甚至一个类，能够保证在同一时刻最多只有一个线程执行该段代码。 public synchronized void yourMethod() { //... }这时,线程获得的是成员锁，即一次只能有一个线程进入该方法，而其他线程要想在此时调用该方法，只能排队等候。只有当前线程(就是在synchroniz
Synchronized 使用方式
User_meng的博客
03-10 164
Synchronized 使用方式 修饰到方法上 以下的m1\m2方法上加锁相当于，把锁加在this对象上，所以只有m1下城执行完成m2线程才可以继续执行 public class T1 { private static synchronized void m1() { for (int i = 0; i < 10; i++) { try { Thread.sleep(1000); Syst
synchronized的4种用法
WJ S的专栏
11-21 1044
原文地址：http://hi.baidu.com/wojiubaibudu/blog/item/a27d671ed654cae6e1fe0b42.html synchronized的4种用法 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchroni
synchronized使用方法
04-27
具体使用方法如下： 1. 修饰方法： ``` public synchronized void method(){ //方法体 } ``` 这样，当有多个线程同时访问这个方法时，只有一个线程可以执行该方法，其他线程需要等待。 2. 修饰代码块： ``` ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值