Java 多线程(1): synchronized关键字详解

最新推荐文章于 2021-02-12 10:13:41 发布
最新推荐文章于 2021-02-12 10:13:41 发布
阅读量223 收藏
点赞数
分类专栏： JAVA 文章标签： JAVA 多线程 synchronized

整理自博客：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html　

多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。

　　同步机制可以使用synchronized关键字实现。

　　当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。

　　当synchronized方法执行完或发生异常时，会自动释放锁。

　　下面通过一个例子来对synchronized关键字的用法进行解析。　　

 

1.是否使用synchronized关键字的不同

复制代码 
public class ThreadTest
{
    public static void main(String[] args)
    {
        Example example = new Example();

        Thread t1 = new Thread1(example);
        Thread t2 = new Thread1(example);

        t1.start();
        t2.start();
    }

}

class Example
{
    public synchronized void execute()
    {
        for (int i = 0; i < 10; ++i)
        {
            try
            {
                Thread.sleep(500);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }

}

class Thread1 extends Thread
{
    private Example example;

    public Thread1(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        example.execute();
    }

}
复制代码

 

　　是否在execute()方法前加上synchronized关键字，这个例子程序的执行结果会有很大的不同。

　　如果不加synchronized关键字，则两个线程同时执行execute()方法，输出是两组并发的。

　　如果加上synchronized关键字，则会先输出一组0到9，然后再输出下一组，说明两个线程是顺次执行的。

 

2.多个方法的多线程情况

　　将程序改动一下，Example类中再加入一个方法execute2()。

　　之后再写一个线程类Thread2，Thread2中的run()方法执行的是execute2()。Example类中的两个方法都是被synchronized关键字修饰的。

复制代码 
public class ThreadTest
{
    public static void main(String[] args)
    {
        Example example = new Example();

        Thread t1 = new Thread1(example);
        Thread t2 = new Thread2(example);

        t1.start();
        t2.start();
    }

}

class Example
{
    public synchronized void execute()
    {
        for (int i = 0; i < 20; ++i)
        {
            try
            {
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }

    public synchronized void execute2()
    {
        for (int i = 0; i < 20; ++i)
        {
            try
            {
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("World: " + i);
        }
    }

}

class Thread1 extends Thread
{
    private Example example;

    public Thread1(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        example.execute();
    }

}

class Thread2 extends Thread
{
    private Example example;

    public Thread2(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        example.execute2();
    }

}
复制代码

 　　如果去掉synchronized关键字，则两个方法并发执行，并没有相互影响。

　　但是如例子程序中所写，即便是两个方法：

　　执行结果永远是执行完一个线程的输出再执行另一个线程的。　　

　　说明：

　　如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

　　结论：

　　当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。

　　Java中的每个对象都有一个锁（lock），或者叫做监视器（monitor），当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法再去访问该对象的synchronized方法了（这里是指所有的同步方法，而不仅仅是同一个方法），直到之前的那个线程执行方法完毕后（或者是抛出了异常），才将该对象的锁释放掉，其他线程才有可能再去访问该对象的synchronized方法。

　　注意这时候是给对象上锁，如果是不同的对象，则各个对象之间没有限制关系。

　　尝试在代码中构造第二个线程对象时传入一个新的Example对象，则两个线程的执行之间没有什么制约关系。

 

3.考虑静态的同步方法

　　当一个synchronized关键字修饰的方法同时又被static修饰，之前说过，非静态的同步方法会将对象上锁，但是静态方法不属于对象，而是属于类，它会将这个方法所在的类的Class对象上锁。

　　一个类不管生成多少个对象，它们所对应的是同一个Class对象。

复制代码 
public class ThreadTest
{
    public static void main(String[] args)
    {
        Example example = new Example();

        Thread t1 = new Thread1(example);

        // 此处即便传入不同的对象，静态方法同步仍然不允许多个线程同时执行
        example = new Example();

        Thread t2 = new Thread2(example);

        t1.start();
        t2.start();
    }

}

class Example
{
    public synchronized static void execute()
    {
        for (int i = 0; i < 20; ++i)
        {
            try
            {
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }

    public synchronized static void execute2()
    {
        for (int i = 0; i < 20; ++i)
        {
            try
            {
                Thread.sleep((long) Math.random() * 1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("World: " + i);
        }
    }

}

class Thread1 extends Thread
{
    private Example example;

    public Thread1(Example example)

    {
        this.example = example;
    }

    @Override
    public void run()
    {
        Example.execute();
    }

}

class Thread2 extends Thread
{
    private Example example;

    public Thread2(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        Example.execute2();
    }

}
复制代码

 

　　所以如果是静态方法的情况（execute()和execute2()都加上static关键字），即便是向两个线程传入不同的Example对象，这两个线程仍然是互相制约的，必须先执行完一个，再执行下一个。

 

　　结论：

　　如果某个synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的类所对应的Class对象。Java中，无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，它们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始。

 

4. synchronized块

　　synchronized块写法：

　　synchronized(object)

　　{　     

　　}

　　表示线程在执行的时候会将object对象上锁。（注意这个对象可以是任意类的对象，也可以使用this关键字）。

　　这样就可以自行规定上锁对象。　

　

复制代码 
public class ThreadTest
{
    public static void main(String[] args)
    {
        Example example = new Example();

        Thread t1 = new Thread1(example);
        Thread t2 = new Thread2(example);

        t1.start();
        t2.start();
    }

}

class Example
{
    private Object object = new Object();

    public void execute()
    {
        synchronized (object)
        {
            for (int i = 0; i < 20; ++i)
            {
                try
                {
                    Thread.sleep((long) Math.random() * 1000);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                System.out.println("Hello: " + i);
            }

        }

    }

    public void execute2()
    {
        synchronized (object)
        {
            for (int i = 0; i < 20; ++i)
            {
                try
                {
                    Thread.sleep((long) Math.random() * 1000);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                System.out.println("World: " + i);
            }

        }

    }

}

class Thread1 extends Thread
{
    private Example example;

    public Thread1(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        example.execute();
    }

}

class Thread2 extends Thread
{
    private Example example;

    public Thread2(Example example)
    {
        this.example = example;
    }

    @Override
    public void run()
    {
        example.execute2();
    }

}
复制代码

　　例子程序4所达到的效果和例子程序2的效果一样（锁单个对象，而不是整个类），都是使得两个线程的执行顺序进行，而不是并发进行，当一个线程执行时，将object对象锁住，另一个线程就不能执行对应的块。

　　synchronized方法实际上等同于用一个synchronized块包住方法中的所有语句，然后在synchronized块的括号中传入this关键字。当然，如果是静态方法，需要锁定的则是class对象。

如下：

　　

锁整个类：注意lock对象是静态的

 

Java代码   收藏代码
  1. public class TestThread {  
  2.      private static Object lock=new Object(); //必须是静态的。  
  3.      public  void execute(){  
  4.          synchronized(lock){  
  5.              for(int i=0;i<100;i++){  
  6.                  System.out.println(i);  
  7.              }      
  8.          }  
  9.      }  
  10. }  

 

 

  锁单个对象：


 

Java代码   收藏代码
  1. public class TestThread {  
  2.     private Object lock=new Object();   
  3.     public  void execute(){  
  4.         synchronized(lock){  //增加了个锁，锁定了对象lock，在同一个类实例中，是线程安全的，但不同的实例还是不安全的。  
  5.   
  6. 因为不同的实例有不同对象锁lock  
  7.             for(int i=0;i<100;i++){  
  8.                    System.out.println(i);  
  9.                }      
  10.            }  
  11.        }  
  12. }  

 

其实上面锁定一个方法，等同于下面的：

 

Java代码   收藏代码
  1. public void execute(){    
  2.     synchronized(this){   //同步的是当然对象  
  3.         for(int i=0;i<100;i++){  
  4.                System.out.println(i);  
  5.            }      
  6.        }  
  7. }  

　　可能一个方法中只有几行代码会涉及到线程同步问题，所以synchronized块比synchronized方法更加细粒度地控制了多个线程的访问，只有synchronized块中的内容不能同时被多个线程所访问，方法中的其他语句仍然可以同时被多个线程所访问（包括synchronized块之前的和之后的）。

　　注意：被synchronized保护的数据应该是私有的。

　　

结论：

　　synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法；

　　synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的其他代码是可以被多个线程同时访问到的。


 

csd54496
关注
专栏目录
Java 多线程：synchronized 多线程同步关键字
不更新了
03-02 1028
前言在 多线程生成的原因（Java内存模型与i++操作解析） 中，介绍了Java的内存模型，从而可能导致的多线程问题。synchronized就是避免这个问题的解决方法之一。除了 synchronized 的方式，还有 lock，condition，volatile，threadlocal，atomicInteger，cas等方式。synchronized 用法它的修饰对象有几种： 1. 修饰一个
java多线程编程之Synchronized关键字详解
09-02
在Java多线程编程中，`Synchronized`关键字扮演着至关重要的角色，它主要用于实现线程之间的互斥访问，确保共享资源的安全性。本篇将深入解析`Synchronized`关键字，探讨其工作原理以及在实际应用中的注意事项。 一...
Java 多线程（六） synchronized关键字详解
weixin_34247032的博客
02-16 184
Java 多线程（六） synchronized关键字详解 　　多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。 　　同步机制可以使用synchronized关键字实现。 　　当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 　　当synchronized方法执行完或发生异常时，会自动释放锁。...
Java多线程中synchronized关键字的用法
starryshi
10-11 142
由于同一进程内的多个线程共享内存空间，在Java中，就是共享实例，当多个线程试图同时修改某个实例的内容时，就会造成冲突，因此，线程必须实现共享互斥，使多线程同步。     最简单的同步是将一个方法标记为synchronized,对同一个实例来说，任一时刻只能有一个synchronized方法在执行。当一个方法正在执行某个synchronized方法时，其他线程如果想要执行这个实例的任意一个sy...
JVM之 - 深入浅出系列之 - synchronized
ApatheCrazyFan的博客
01-03 1000
深入浅出synchronized synchronized可以保证方法或代码块在运行时，同一时刻只有一个线程可以进入到临界区（互斥性），同时它还保证了共享变量的内存可见性。 Java中的每个对象都可以作为锁。 普通同步方法，锁是当前实例对象。静态同步方法，锁是当前类的class对象。同步代码块，锁是括号中的对象。 先看一个场景 等待 / 通知机制 直接上代码：
java多线程死锁_Java多线程7：死锁
weixin_29027285的博客
02-12 71
前言死锁单独写一篇文章是因为这是一个很严重的、必须要引起重视的问题。这不是夸大死锁的风险，尽管锁被持有的时间通常很短，但是作为商业产品的应用程序每天可能要执行数十亿次获取锁->释放锁的操作，只要在这数十亿次操作中只要有一次发生了错误，就可能导致程序中发生死锁，并且即使通过压力测试也不可能找出所有潜在的死锁。死锁一个经典的多线程问题。当一个线程永远地持有一个锁，并且其他线程都尝试去获得这个锁时...
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
"Java多线程与并发：synchronized关键字详解及应用
通过本文的学习，读者将更深入地理解Synchronized关键字在Java多线程编程中的重要性，以及如何更加高效地利用它来实现线程安全和同步。 在学习中，读者可以带着一些BAT大厂的面试问题，这将有助于更好地理解...
java多线程-Synchronized关键字详解
lijianbiao0的博客
05-30 747
Synchronized关键字开篇定义作用应用场景原理具体使用使用方式特别注意其他控制并发 / 线程同步方式Lock、ReentrantLock简介区别Compare And Swap（CAS）定义：原理优点典型应用：AtomicInteger 开篇 在Java中，有一个常被忽略 但 非常重要的关键字Synchronized 今天，我将详细讲解 Java关键字Synchronized的所有知识，希...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
synchronized解析
pipi蛋
05-26 171
synchronized是jvm级别的一种重量级锁，但是随着jdk对synchronized的不断优化，现在它已经变得没有我们想象的那么重了。由于synchronized使用简单，也不用手动释放锁，因此我们平时开发中用到最多的锁就是它了。 synchronized锁的三种形式 普通方法：锁是当前对象实例 静态方法：锁是当前类的Class对象 同步方法块：锁是synchronized括号里的对象 实现原理 同步代码块在编译后会在前后分别插入monitorenter和monitorexit指令，每个对象在同
Java synchronized 解析
巴士飞扬-busfly.cn-的专栏
03-26 938
google_ad_client = "pub-8432098110340913";/* 250x250, office2007_内容区左上广告,创建于 08-2-13 */google_ad_slot = "3493930840";google_ad_width = 250;google_ad_height = 250;//--> Tags:[java]  [syn
synchronized原理解析
l1394049664的博客
08-06 1195
  目录 一、synchronized的使用场景 二、原理分析 1、同步方法 2、同步代码块 3、对象，对象监视器，同步队列以及执行线程状态之间的关系 4、总结 三、synchronized在原子性、可见性和有序性的体现 1、synchronized与原子性 2、synchronized与可见性 3、synchronized与有序性 四、synchronized锁优化（提高...
Java中的锁（七）
西木风落
10-06 223
本章主要介绍Java中的计数器CountDownLatch。 一、CountdownLatch的基本概念 countdownLatch也叫闭锁，与cyclicBarrier一样，也是在jdk1.5中的并发包引入的。CountDownLatch内部会维护一个初始值为线程数量的计数器，主线程执行await方法，如果计数器大于0，则阻塞等待。当一个线程完成任务后，计数器值减1。当计数器为0时，表示所...
Java多线程 —— synchronized关键字详解
qq_42499816的博客
09-24 317
一、多线程的同步 1、为什么要引入同步机制 在多线程环境中，可能会有两个甚至更多的线程试图同时访问一个有限的资源。必须对这种潜在资源冲突进行预防。 解决方法：在线程使用一个资源时为其加锁即可。 访问资源的第一个线程为其加上锁以后，其他线程便不能再使用那个资源，除非被解锁。 2、实例 用一个取钱的程序例子，来说明为什么需要引入同步。在使用同步机制前，整体程序如下： package com.demo;...
深入理解Java并发编程：synchronized关键字详解
在并发编程中，synchronized关键字是Java语言提供的一种重要的机制，用于确保多线程环境下的数据一致性与线程安全性。本文档将深入探讨synchronized的关键原理和用法，包括同步代码块和同步方法。 **同步代码块：**...
synchronized 关键字
u014381863的博客
12-21 547
synchronized 关键字在并发编程中，多个线程访问临界资源有时会造成数据的不一致，这时我们可以对临界资源加上同步锁，保证在同一时间只有一个线程能够访问临界资源。Java 中的同步块用 synchronized 标记。同步块在 Java 中是同步在某个对象上。所有同步在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞，直到执行该同步块中的线程退出。
synchronized关键字
故事就酒的博客
02-27 807
synchronized定义 synchronized关键字是Java多线程中经常使用到的一个关键字。代表这个方法加锁,相当于不管哪一个线程（例如线程A），运行到这个方法时,都要检查有没有其它线程B（或者C、 D等）正在用这个方法(或者该类的其他同步方法)，有的话要等正在使用synchronized方法的线程B（或者C 、D）运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。它包...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值