Java中Synchronized的用法（简单介绍）

时间  2019-11-07
标签 java synchronized 用法 简单 介绍 栏目 Java 繁體版
原文   原文链接

简单介绍

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有如下几种： 

　　1. 修饰一个代码块，被修饰的代码块称为同步语句块，其做用的范围是大括号{}括起来的代码，做用的对象是调用这个代码块的对象； 
　　2. 修饰一个方法，被修饰的方法称为同步方法，其做用的范围是整个方法，做用的对象是调用这个方法的对象； 
　　3. 修改一个静态的方法，其做用的范围是整个静态方法，做用的对象是这个类的全部对象； 
　　4. 修改一个类，其做用的范围是synchronized后面括号括起来的部分，做用主的对象是这个类的全部对象。java

修饰一个代码块

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

　例子：并发

package com.wbg;

import java.util.ArrayList;
import java.util.List;

public class kt {
    public static void main(String[] args) {
        System.out.println("使用关键字synchronized");
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}
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;
    }
}
View Code

使用关键字synchronized运行结果 

不使用关键字synchronized运行结果

当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程获得执行，另外一个线程受阻塞，必须等待当前线程执行完这个代码块之后才能执行该代码块。Thread1和thread2是互斥的，由于在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象。 
咱们再把SyncThread的调用稍微改一下：ide

 

public static void main(String[] args) {
        System.out.println("使用关键字synchronized每次调用进行new SyncThread()");
        Thread thread1 = new Thread( new SyncThread(), "SyncThread1");
        Thread thread2 = new Thread( new SyncThread(), "SyncThread2");
        thread1.start();
        thread2.start();
    }

运行结果

为何上面的例子中thread1和thread2同时在执行。这是由于synchronized只锁定对象，每一个对象只有一个锁（lock）与之相关联，而上面的代码等同于下面这段代码：函数

public static void main(String[] args) {
        System.out.println("使用关键字synchronized每次调用进行new SyncThread()");
        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对象，而这两把锁是互不干扰的，不造成互斥，因此两个线程能够同时执行。this

 2、当一个线程访问对象的一个synchronized(this)同步代码块时，另外一个线程仍然能够访问该对象中的非synchronized(this)同步代码块。 

　　多个线程访问synchronized和非synchronized代码块

　　　　

 public static void main(String[] args) {
        System.out.println("使用关键字synchronized");
        Mthreads mt=new Mthreads();
        Thread thread1 = new Thread(mt, "mt1");
        Thread thread2 = new Thread(mt, "mt2");
        thread1.start();
        thread2.start();
    }
}
class Mthreads implements Runnable{
    private int count;

    public Mthreads() {
        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("mt1")) {
            countAdd();
        } else if (threadName.equals("mt2")) {
            printCount();
        }
    }
View Code

运行结果

　　

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

修饰一个方法

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，public synchronized void method(){}; synchronized修饰方法和修饰一个代码块相似，只是做用范围不同，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。如将的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();
                }
            }
        }
    }

运行结果3d

Synchronized做用于整个方法的写法。 

写法一:code

public synchronized void method()
{
   // todo
}

写法二:对象

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

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

在用synchronized修饰方法时要注意如下几点： 
1. synchronized关键字不能继承。 
虽然可使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，所以，synchronized关键字不能被继承。若是在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认状况下并非同步的，而必须显式地在子类的这个方法中加上synchronized关键字才能够。固然，还能够在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，所以，子类的方法也就至关于同步了。这两种方式的例子代码以下： 
在子类方法中加上synchronized关键字

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

在定义接口方法时不能使用synchronized关键字。

构造方法不能使用synchronized关键字，但可使用synchronized代码块来进行同步。

修饰一个静态的方法

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

public synchronized static void method() {
   
}

咱们知道静态方法是属于类的而不属于对象的。一样的，synchronized修饰的静态方法锁定的是这个类的全部对象。

synchronized修饰静态方法

package com.wbg;

import java.util.ArrayList;
import java.util.List;

public class kt {
    public static void main(String[] args) {
        System.out.println("使用关键字静态synchronized");
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}
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();
    }
}
View Code

运行结果

syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是由于run中调用了静态方法method，而静态方法是属于类的，因此syncThread1和syncThread2至关于用了同一把锁。这与使用关键字synchronized运行结果相同

修饰一个类

Synchronized还可做用于一个类，用法以下：

package com.wbg;

import java.util.ArrayList;
import java.util.List;

public class kt {
    public static void main(String[] args) {
        System.out.println("使用ClassName");
        SyncThread syncThread = new SyncThread();
        Thread thread1 = new Thread(syncThread, "SyncThread1");
        Thread thread2 = new Thread(syncThread, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}
class ClassName {
    public void method() {
        synchronized(ClassName.class) {

        }
    }
}
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();
    }
}
View Code

运行结果

 

效果和上面synchronized修饰静态方法是同样的，synchronized做用于一个类T时，是给这个类T加锁，T的全部对象用的是同一把锁。

 总结:

一、 不管synchronized关键字加在方法上仍是对象上，若是它做用的对象是非静态的，则它取得的锁是对象；若是synchronized做用的对象是一个静态方法或一个类，则它取得的锁是对类，该类全部的对象同一把锁。 二、每一个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就能够运行它所控制的那段代码。 三、实现同步是要很大的系统开销做为代价的，甚至可能形成死锁，因此尽可能避免无谓的同步控制

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程