synchronized 订阅
synchronized 关键字,代表这个方法加锁,相当于不管哪一个线程(例如线程A),运行到这个方法时,都要检查有没有其它线程B(或者C、 D等)正在用这个方法(或者该类的其他同步方法),有的话要等正在使用synchronized方法的线程B(或者C 、D)运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。它包括两种用法:synchronized 方法和 synchronized 块。Java语言的关键字,可用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而,当一个线程访问object的一个加锁代码块时,另一个线程仍可以访问该object中的非加锁代码块。 展开全文
synchronized 关键字,代表这个方法加锁,相当于不管哪一个线程(例如线程A),运行到这个方法时,都要检查有没有其它线程B(或者C、 D等)正在用这个方法(或者该类的其他同步方法),有的话要等正在使用synchronized方法的线程B(或者C 、D)运行完这个方法后再运行此线程A,没有的话,锁定调用者,然后直接运行。它包括两种用法:synchronized 方法和 synchronized 块。Java语言的关键字,可用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而,当一个线程访问object的一个加锁代码块时,另一个线程仍可以访问该object中的非加锁代码块。
信息
外文名
synchronized
美式发音
美['sɪŋkrənaɪzd]
方法声明
放在范围操作符
中文名
Java语言的关键字
代    表
方法加锁
英式发音
英['sɪŋkrənaɪzd]
synchronized方法
synchronized 方法1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.  例如:如在线程t1中有语句obj.synMethod(); 那么由于synMethod被synchronized修饰,在执行该语句前, 需要先获得调用者obj的对象锁, 如果其他线程(如t2)已经锁定了obj (可能是通过obj.synMethod,也可能是通过其他被synchronized修饰的方法obj.otherSynMethod锁定的obj), t1需要等待直到其他线程(t2)释放obj, 然后t1锁定obj, 执行synMethod方法. 返回之前释放obj锁.2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.此时,线程获得的是成员锁.例如:  3.synchronized后面括号里是一对象,此时,线程获得的是对象锁.例如:  对于3,如果线程进入,则得到当前对象锁,那么别的线程在该类所有对象上的任何操作都不能进行.在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁,而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源?如果一个对象拥有多个资源,就不需要只为了让一个线程使用其中一部分资源,就将所有线程都锁在外面。由于每个对象都有锁,可以如下所示使用虚拟对象来上锁:  4.synchronized后面括号里是类,此时,线程获得的是对象锁.例如:  对于4,如果线程进入,则线程在该类中所有操作不能进行,包括静态变量和静态方法,实际上,对于含有静态方法和静态变量的代码块的同步,我们通常用4来加锁.
收起全文
精华内容
下载资源
问答
  • synchronized

    2020-06-19 23:59:22
    synchronized 关键字的用法1. synchronized 关键字可以用来修饰方法定义2. synchronized 关键字用来修饰代码块2. 理解使用 synchronized 关键字3. 理解同步4. 怎样判断线程之间是否同步5. 使用 synchronized 关键字...

    1. synchronized 关键字的用法

    synchronized 关键字主要是用于对其引用所指向的对象进行加锁

    1. synchronized 关键字可以用来修饰方法定义

        // 修饰实例方法
        public synchronized void method() {
        }
        
        // 修饰静态方法
        public static synchronized void sMethod() {
        }
    

    2. synchronized 关键字用来修饰代码块

           Object o = new Object();
           // synchronized 后面的括号里跟着指向对象的引用, 引用不能为 null
           
           synchronized (o) {
           }
    
           synchronized (this) {
           }
    
           // 反射中, 指向当前类对象
           synchronized (Math.class) {
           }
    

    2. 理解使用 synchronized 关键字

    1. synchronized (引用), 代表对当前"引用"所指的对象 进行加锁
    2. 一个线程在对一个引用所指的对象进行加锁时, 需要先判断该锁是否已经被占用, 若未被占用, 就可以进行加锁, 代表请求锁成功.
    3. 若请求锁失败, 该线程就会放弃 CPU 且放弃抢占 CPU 的资格, 从而进入到阻塞态(BLOCKED 状态 -----> 专门为 synchronized 所设计的一种阻塞状态), 等待锁的释放

    3. 理解同步

    对于多线程而言, 有线程间一定的干扰就是同步, 而线程间毫无联系就是异步

    通常情况下, synchronized 修饰的方法就称为同步方法. 它可以使多个线程之间产生同步效果(通过加锁产生同步效果)

    1. 对实例方法加锁:
     public synchronized void method() {
     }
     // 二者是等价的
     public void method() {
            synchronized (this) {
            }
        } 
    
    1. 对静态方法加锁
     public static synchronized void sMethod() {
     }
     // 二者是等价的
     public static void sMethod() {
            synchronized (类名.class) {
            }
     }
    

    4. 怎样判断线程之间是否同步

    1. 调用的方法是否都有加锁动作
    2. 加锁加的是否是同一把锁(同一个对象)

    5. 使用 synchronized 关键字怎样解决代码中的线程不安全隐患

    无论什么方法, 解决代码中线程不安全隐患都需要从 原子性/内存可见性/代码重排序 三个角度出发
    使用了synchronized 关键字
    在这里插入图片描述

    1. 从原子行角度讲:
      线程从请求锁成功到释放锁的这一过程中, 保证了原子性
    2. 从内存可见性角度讲:
      (1). 请求锁成功后, JVM 会刷新线程的工作内存, 从而保证线程读到的数据是最新的
      (2). 释放锁后, JVM 会将线程工作内存中的数据, 刷新回主内存中, 从而保证其他线程在读取工作内存中的数据时是最新的数据
    3. 从代码重排序角度讲:
      对于 A, B, C三部分而言, 其各自内部可以随意重排序, 但是每一部分不能重排序其余部分
    展开全文
  • 【Java并发编程之深入理解】Synchronized的使用

    万次阅读 多人点赞 2018-09-08 20:56:16
    1.为什么要使用synchronized 在并发编程中存在线程安全问题,主要原因有:1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻,只有一个线程可以执行某个方法或某个代码块,同时...

    1.为什么要使用synchronized

    在并发编程中存在线程安全问题,主要原因有:1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻,只有一个线程可以执行某个方法或某个代码块,同时synchronized可以保证一个线程的变化可见(可见性),即可以代替volatile。

    2.实现原理

    synchronized可以保证方法或者代码块在运行时,同一时刻只有一个方法可以进入到临界区,同时它还可以保证共享变量的内存可见性

    3.synchronized的三种应用方式

    Java中每一个对象都可以作为锁,这是synchronized实现同步的基础:

    1. 普通同步方法(实例方法),锁是当前实例对象 ,进入同步代码前要获得当前实例的锁
    2. 静态同步方法,锁是当前类的class对象 ,进入同步代码前要获得当前类对象的锁
    3. 同步方法块,锁是括号里面的对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。

    4.synchronized的作用

    Synchronized是Java中解决并发问题的一种最常用最简单的方法 ,他可以确保线程互斥的访问同步代码

    5.举栗子

    **一、synchronized作用于实例方法**

    ①多个线程访问同一个对象的同一个方法

    public class synchronizedTest implements Runnable {
        //共享资源
        static int i =0;
        /**
         * synchronized 修饰实例方法
         */
        public synchronized void increase(){
            i++;
        }
        @Override
        public void run(){
            for (int j =0 ; j<10000;j++){
                increase();
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            synchronizedTest test = new synchronizedTest();
            Thread t1 = new Thread(test);
            Thread t2 = new Thread(test);
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(i);
        }
    }
    
    

    结果:
    这里写图片描述
    分析:当两个线程同时对一个对象的一个方法进行操作,只有一个线程能够抢到锁。因为一个对象只有一把锁,一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,就不能访问该对象的其他synchronized实例方法,需要等到对象被释放后才能获取,但是在对象没有被释放前,其他线程可以访问非synchronized修饰的方法

    ②一个线程获取了该对象的锁之后,其他线程来访问其他synchronized实例方法现象 举栗

    public class SynchronizedTest {
        public synchronized void method1() {
            System.out.println("Method 1 start");
            try {
                System.out.println("Method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 end");
        }
    
        public synchronized void method2() {
            System.out.println("Method 2 start");
            try {
                System.out.println("Method 2 execute");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 2 end");
        }
    
    
        public static void main(String[] args) {
            final SynchronizedTest test = new SynchronizedTest();
    
            new Thread(test::method1).start();
    
            new Thread(test::method2).start();
        }
    
    }
    
    

    结果:
    这里写图片描述
    分析:可以看出其他线程来访问synchronized修饰的其他方法时需要等待线程1先把锁释放

    ③一个线程获取了该对象的锁之后,其他线程来访问其他非synchronized实例方法现象 举栗
    去掉②中方法二的synchronized

    public class SynchronizedTest {
        public synchronized void method1() {
            System.out.println("Method 1 start");
            try {
                System.out.println("Method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 end");
        }
    
        public void method2() {
            System.out.println("Method 2 start");
            try {
                System.out.println("Method 2 execute");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 2 end");
        }
    
    
        public static void main(String[] args) {
            final SynchronizedTest test = new SynchronizedTest();
    
            new Thread(test::method1).start();
            new Thread(test::method2).start();
        }
    
    }
    
    

    结果:
    这里写图片描述
    分析:当线程1还在执行时,线程2也执行了,所以当其他线程来访问非synchronized修饰的方法时是可以访问的

    ④当多个线程作用于不同的对象

    public class SynchronizedTest {
        public synchronized void method1() {
            System.out.println("Method 1 start");
            try {
                System.out.println("Method 1 execute");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 1 end");
        }
    
        public synchronized void method2() {
            System.out.println("Method 2 start");
            try {
                System.out.println("Method 2 execute");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Method 2 end");
        }
    
    
        public static void main(String[] args) {
            final SynchronizedTest test1 = new SynchronizedTest();
            final SynchronizedTest test2 = new SynchronizedTest();
    
            new Thread(test1::method1).start();
    
            new Thread(test2::method2).start();
        }
    
    }
    
    

    结果:
    在这里插入图片描述
    分析:因为两个线程作用于不同的对象,获得的是不同的锁,所以互相并不影响

    **此处思考一个问题:为什么分布式环境下synchronized失效?如何解决这种情况?**
    **二、synchronized作用于静态方法**
    public class synchronizedTest implements Runnable {
        //共享资源
        static int i =0;
        /**
         * synchronized 修饰实例方法
         */
        public static synchronized void increase(){
            i++;
        }
        @Override
        public void run(){
            for (int j =0 ; j<10000;j++){
                increase();
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(new synchronizedTest());
            Thread t2 = new Thread(new synchronizedTest());
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println(i);
        }
    

    结果:
    这里写图片描述
    分析:由例子可知,两个线程实例化两个不同的对象,但是访问的方法是静态的,两个线程发生了互斥(即一个线程访问,另一个线程只能等着),因为静态方法是依附于类而不是对象的,当synchronized修饰静态方法时,锁是class对象。

    **三、synchronized作用于同步代码块**

    为什么要同步代码块呢?在某些情况下,我们编写的方法体可能比较大,同时存在一些比较耗时的操作,而需要同步的代码又只有一小部分,如果直接对整个方法进行同步操作,可能会得不偿失,此时我们可以使用同步代码块的方式对需要同步的代码进行包裹,这样就无需对整个方法进行同步操作了。

     public class synchronizedTest implements Runnable {
        static synchronizedTest instance=new synchronizedTest();
        static int i=0;
        @Override
        public void run() {
            //省略其他耗时操作....
            //使用同步代码块对变量i进行同步操作,锁对象为instance
            synchronized(instance){
                for(int j=0;j<10000;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++;
        }
    }
    
    展开全文
  • Synchronized

    千次阅读 2018-11-27 16:05:31
    1.synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种:  (1) 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;  ...

    参考:https://blog.csdn.net/luoweifu/article/details/46613015

    1.synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种: 
    (1) 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象; 
    (2)修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象; 
    (3)修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象; 
    (4)修改一个类,其作用的范围是synchronized后面括号括起来的部分,作用主的对象是这个类的所有对象。

    2.修饰代码块

    package com.ysl.rxjava.SyncThread;
    
    public class SyncThread implements Runnable {
        private 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 static void main(String[] args) {
    		SyncThread s = new SyncThread();
            Thread t1 = new Thread(s);
            Thread t2 = new Thread(s);
    
            t1.start();
            t2.start();
        }
    }

    输出结果:

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

    我们修改一下调用:

    public static void main(String[] args) {
            SyncThread s1 = new SyncThread();
            SyncThread s2 = new SyncThread();
            Thread t1 = new Thread(s1);
            Thread t2 = new Thread(s2);
    
            t1.start();
            t2.start();
        }

    再来看结果:

    可以看到线程1和线程2同时进行了,这是因为他们操作的是两个完全不同的对象。所以,

    synchronized只锁定对象,每个对象只有一个锁(lock)与之相关联,这时会有两把锁分别锁定syncThread1对象和syncThread2对象,而这两把锁是互不干扰的,不形成互斥,所以两个线程可以同时执行。

    代码块中  synchronized(。。。) :

    当填写this时,写成synchronized(this) { }:代表使用类生成的对象作为锁;同以对象时阻塞,不同对象时各自可以同时执行。

    当填写SyncThread.class时,写成synchronized(SyncThread.class) { }:代表使用类的字节码作为锁;所以对象公用一个锁,线程会阻塞。

    当在此类中new一个锁对象呢,private bject object = new Object();

    写成synchronized(object) { }:这种情况和this是一样的结果,因为在new不同的对象时,锁object也会被new出来。

    当在此类中有一个静态的锁对象呢,private static bject object = new Object();

    写成synchronized(object) { }:这种情况和SyncThread.class是一样的结果,因为在new不同的对象时,锁object是静态的,属于类的,不会被new出来。所有的线程都会公用这个静态对象。使用同一把锁。

    2.修饰普通方法:

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

    public synchronized void method()
    {
       // todo
    }

    写法二:

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

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

    package com.ysl.rxjava.SyncThread;
    
    public class SyncThread2 {
    
        private static int count;
    
        public synchronized void test1(){
            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 test2() {
            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 static synchronized void test3(){
            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 test4() {
            synchronized(SyncThread2.class) {
                for (int i = 0; i < 5; i ++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + ":" + (count++));
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
    }
    

    下面来调用做对比:

    (1)test1修饰方法和test2修改代码块一样

    public static void main(String[] args) {
            SyncThread2 syncThread2 = new SyncThread2();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    syncThread2.test2();
    //                new SyncThread2().test1();
                }
            }, "A");
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    syncThread2.test2();
    //                new SyncThread2().test1();
                }
            }, "B");
    
            thread1.start();
            thread2.start();
        }

    运行结果和上面的第一种情况是一样的;同一个对象的时候,线程是阻塞的,其中一个执行完了才能执行另一个线程。当使用new的方式,取不同对象时,不受影响,可以并行执行。

    (2)代码块中使用类名.class来作为同步锁对象

    public static void main(String[] args) {
            SyncThread2 syncThread2 = new SyncThread2();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
    //                syncThread2.test4();
                    new SyncThread2().test4();
                }
            }, "A");
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
    //                syncThread2.test4();
                    new SyncThread2().test4();
                }
            }, "B");
    
            thread1.start();
            thread2.start();
        }

    上面两种方式的输出结果是一样的:

    可以看到执行时两个线程是会安照一定顺序来进行的。这是由于test4的锁对象是个class,而在Java中只会生成一个class文件,也就是锁对象是唯一的。那么当一个线程拿到这个class锁对象执行任务时,另一个线程因为获取不到锁对象只能在那等着。只有前一个执行完成,释放了锁,另一个线程才能拿到这个锁去执行自己的任务。

    3.修饰静态方法:

    接着使用上面的类,改变调用方法test3:

    public static void main(String[] args) {
            SyncThread2 syncThread2 = new SyncThread2();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
    //                syncThread2.test3();
                    new SyncThread2().test3();
                }
            }, "A");
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
    //                syncThread2.test3();
                    new SyncThread2().test3();
                }
            }, "B");
    
            thread1.start();
            thread2.start();
        }

    结果和上面的使用class作为锁的结果是一样的。

    可以看到:当使用static修饰以后;不管是使用同一个对象还是new的两个完全不同的对象。他们同样会阻塞另一个线程。直到前一个线程的任务执行完。其实静态方法是属于类的,和class是一样的。

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

    总结:

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

     

    展开全文
  • Java中Synchronized的用法

    万次阅读 多人点赞 2015-06-24 00:25:01
    synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种: 1. 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象; 2. 修饰一...

    原文:http://blog.csdn.net/luoweifu/article/details/46613015
    作者:luoweifu
    转载请标名出处


    编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程》一文详细讲述了线程、进程的关系及在操作系统中的表现,这是多线程学习必须了解的基础。本文将接着讲一下Java线程同步中的一个重要的概念synchronized.

    synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种:
    1. 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;
    2. 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
    3. 修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;
    4. 修改一个类,其作用的范围是synchronized后面括号括起来的部分,作用主的对象是这个类的所有对象。


    修饰一个代码块

    1. 一个线程访问一个对象中的synchronized(this)同步代码块时,其他试图访问该对象的线程将被阻塞。我们看下面一个例子:

    【Demo1】:synchronized的用法

    /**
     * 同步线程
     */
    class SyncThread implements Runnable {
       private static int count;
    
       public SyncThread() {
          count = 0;
       }
    
       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)中的synchronized代码块时,在同一时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块。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
    SyncThread2:6
    SyncThread1: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对象,而这两把锁是互不干扰的,不形成互斥,所以两个线程可以同时执行。


    2.当一个线程访问对象的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。
    【Demo2】:多个线程访问synchronized和非synchronized代码块

    class Counter implements Runnable{
       private int count;
    
       public Counter() {
          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();
                }
             }
          }
       }
    
       //非synchronized代码块,未对count进行读写操作,所以可以不用synchronized
       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();
             }
          }
       }
    
       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
    A:2
    B count:3
    A:3
    B count:4
    A:4
    B count:5

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


    1. 指定要给某个对象加锁

    【Demo3】:指定要给某个对象加锁

    /**
     * 银行账户类
     */
    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;
       }
    
       public void run() {
          synchronized (account) {
             account.deposit(500);
             account.withdraw(500);
             System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
          }
       }
    }

    调用代码:

    Account account = new Account("zhang san", 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();
    }

    结果如下:

    Thread3:10000.0
    Thread2:10000.0
    Thread1:10000.0
    Thread4:10000.0
    Thread0: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 同步代码块
          }
       }
    
       public void run() {
    
       }
    }

    说明:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:生成零长度的byte[]对象只需3条操作码,而Object lock = new Object()则需要7行操作码。

    修饰一个方法

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

    *【Demo4】:synchronized修饰一个方法

    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】: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();
       }
    }

    调用代码:

    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

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



    修饰一个类

    Synchronized还可作用于一个类,用法如下:

    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的所有对象用的是同一把锁。



    总结:

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


    参考资料:
    http://blog.csdn.net/chenguang79/article/details/677720
    http://developer.51cto.com/art/200906/132354.htm



    此处搭一个广告:欢迎阅读最新专辑《从生活中领悟设计模式(Python)》:用生活中的故事和细节,别开生面的解读设计模式。扫描下方二维码进入:
    这里写图片描述


    原文:http://blog.csdn.net/luoweifu/article/details/46613015
    作者:luoweifu
    转载请标名出处



    关注【SunLogging】
    这里写图片描述
    长按或扫码二维码,在手机端阅读更多内容

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,589
精华内容 32,635
热门标签
关键字:

synchronized