首页 > > 程序设计 > Java技术 >

2.3多线程（java学习笔记）synchronized关键字

2018-08-13 07:39:18来源：博客园阅读 ()

一、为什么要用synchronized关键字

首先多线程中多个线程运行面临共享数据同步的问题。

多线程正常使用共享数据时需要经过以下步骤：

1.线程A从共享数据区中复制出数据副本，然后处理。

2.线程A将处理好的数据副本写入共享数据区。

3.线程B从共享数据区中复制出数据副本。

如此循环，直到线程结束。

假如线程A从共享数据区中复制出数据副本然后处理，在还没有将更新的数据放入主内存时，线程B来到主内存读取了未更新的数据，这样就出问题了。

这就是所谓的脏读，这类问题称为多线程的并发问题。

举个具体的例子：

 1 public class TestThread {
 2      public static void main(String[] args){
 3          TestSynchronized s = new TestSynchronized();
 4          new Thread(s,"t1").start();    //两个线程访问一个对象
 5          new Thread(s,"t2").start();
 6      }
 7 }
 8 
 9 class TestSynchronized implements Runnable{
10     private int ticket = 5;
11     
12     public void run(){    
13             for(int p = 0; p < 10; p++){
14                 try {
15                     Thread.sleep(500);
16                 } catch (InterruptedException e) {
17                     // TODO Auto-generated catch block
18                     e.printStackTrace();
19                 }
20                 if(ticket >= 0){
21                     System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
22                 }
23             }
24     }
25 }

运行结果：
t2 ticket:4
t1 ticket:5
t1 ticket:2
t2 ticket:3
t1 ticket:1
t2 ticket:1
t2 ticket:0

可以看到1号票同时给了t1和t2，当t1读入1执行了ticket--后，数据还没有来得及写入主内存就被t2从主内存中读走了1，就造成了这种现象。

要想避免这种现象就需要使用synchronized关键字，synchronized英译为同步，我们认为暂且把他看做锁定更好理解。

接下来我们看看synchronized如何使用。

二、synchronized的用法

1. synchronized修饰方法（也称同步方法）

(1) java中每个对象都有一个锁（lock）,或者叫做监视器，当前线程访问某个对象中synchronized修饰的方法（同步块）时，线程需要获取到该对象的锁，获取对象锁后才能访问该对象中synchronized方法（同步块），且一个对象中只有一个锁。

(2) 没有获得该对象的锁的其他线程，无法访问该对象中synchronized修饰的方法（同步块）。

(3) 其他线程要想访问该对象中synchronized修饰的方法需要获取该对象的锁。

(4) 对象锁只有将synchronized方法（同步块）中的内容运行完毕或遇到异常才会释放锁。

例一：

 1 public class TestThread {
 2      public static void main(String[] args){
 3          TestSynchronized s = new TestSynchronized();
 4          new Thread(s,"t1").start();     //两个线程访问一个对象
 5          new Thread(s,"t2").start();
 6      }
 7 }
 8 
 9 class TestSynchronized implements Runnable{
10     private int ticket = 5;
11     
12     synchronized public void run(){    
13             for(int p = 0; p < 10; p++){
14                 try {
15                     Thread.sleep(500);
16                 } catch (InterruptedException e) {
17                     // TODO Auto-generated catch block
18                     e.printStackTrace();
19                 }
20                 if(ticket >= 0){
21                     System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
22                 }                    
23             }
24         }
25 }

运行结果：
t1 ticket:5
t1 ticket:4
t1 ticket:3
t1 ticket:2
t1 ticket:1
t1 ticket:0

我们来分析上面程序，首先线程t1进去run方法获得对象s的锁，然后执行完run方法释放锁，run运行忘了也就没有t2的事了。

因为只有将synchronized修饰的方法执行完才会释放锁，故打印五个t1.。

还有一点，如果一个对象里面有多个synchronized方法，某一时刻只能有一个线程进入其中一个synchronized修饰的方法，则这时其他任何线程无法进入该对象中任何一个synchronized修饰的方法。

补充片段：

 1 public class TestThread {
 2     public static void main(String[] args){
 3         Test m1 = new Test();  //两个线程共访问一个对象。
 4 
 5         TestSynchronized_1 s1 = new TestSynchronized_1(m1);
 6         TestSynchronized_2 s2 = new TestSynchronized_2(m1);
 7         new Thread(s1,"t1").start();
 8         new Thread(s2,"t2").start();
 9     }
10 }
11 
12 class Test{
13     synchronized public void test1(){
14                for(int p = 0; p < 5; p++){
15                    System.out.println("s1.run.TestSynchronized_test 1");
16                }   
17     }
18     
19     synchronized public void test2(){
20         for(int p = 0; p < 5; p++){
21             System.out.println("s2.run.TestSynchronized_test 2");
22         }   
23 }
24 }
25 
26 class TestSynchronized_1 implements Runnable{
27    
28    private Test m;
29    public TestSynchronized_1(Test m){
30       this.m = m;
31    }
32    
33    public void run(){
34        m.test1();
35    }
36 }
37 
38 class TestSynchronized_2 implements Runnable{
39        
40        private Test m;
41        public TestSynchronized_2(Test m){
42           this.m = m;
43        }
44        
45        public void run(){
46            m.test2();
47        }
48 }

运行结果：
s1.run.TestSynchronized_test 1
s1.run.TestSynchronized_test 1
s1.run.TestSynchronized_test 1
s1.run.TestSynchronized_test 1
s1.run.TestSynchronized_test 1
s2.run.TestSynchronized_test 2
s2.run.TestSynchronized_test 2
s2.run.TestSynchronized_test 2
s2.run.TestSynchronized_test 2
s2.run.TestSynchronized_test 2

当线程t1运行synchronized修饰的test1方法时，线程t2是无法运行test2方法。结合之前说的，一个对象锁只有一把，而这里是两个线程共享对象（m1）,当线程t1获得锁时，线程t2就只能等待。归根结底把握几个要点：

1.锁的唯一性（一个对象只有一把锁，但不同对象就有不同的锁）

2.没锁不能进去入synchronized修饰内容中运行。

3.只有运行完synchronized修饰的内容或遇到异常才释放锁。

我们来看下面这个代码：

例二：

 1 public class TestThread {
 2      public static void main(String[] args){
 3          Mouth m1 = new Mouth();  
 4          Mouth m2 = new Mouth();  
 5          TestSynchronized s1 = new TestSynchronized(m1);//两个线程访问两个对象。
 6          TestSynchronized s2 = new TestSynchronized(m2);
 7          new Thread(s1,"t1").start();  //线程t1
 8          new Thread(s2,"t2").start();   //线程t2
 9      }
10 }
11 
12 class Mouth{  //资源及方法 
13     synchronized public void test(){
14         int ticket = 5;
15         for(int p = 0; p < 10; p++){
16             try {
17                 Thread.sleep(500);
18             } catch (InterruptedException e) {
19                 // TODO Auto-generated catch block
20                 e.printStackTrace();
21             }
22             if(ticket >= 0){
23                 System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
24             }                    
25         }
26     }
27 
28 }
29 
30 class TestSynchronized implements Runnable{
31     private Mouth m = new Mouth();
32     
33     public TestSynchronized(Mouth m){
34         this.m = m;
35     }
36     
37     synchronized public void run(){
38         m.test();
39     }
40 }

运行结果：
t1 ticket:5
t2 ticket:5
t2 ticket:4
t1 ticket:4
t1 ticket:3
t2 ticket:3
t2 ticket:2
t1 ticket:2
t1 ticket:1
t2 ticket:1
t2 ticket:0
t1 ticket:0

可以发现好像用synchronized修饰的test方法没有起作用，怎么是t1，t2怎么是交替运行的？

我们回顾下之前说的对象锁，线程获得对象锁后可以访问该对象里面synchronized修饰的方法，其他线程无法访问。

我们上面的代码里面对象有两个，一个是m1、一个是m2。

t1获得了对象m1的锁，然后访问m1中的test方法；t2获得了对象m2的锁，然后访问s2中的test方法。

线程t1和线程t2访问的是不同的资源（m1，m2），并不相互干扰所以没有影响。例一中是因为两个线程访问同一个资源（s1）所以synchronized的起了限制作用。

synchronized修饰方法时只能对多个线程访问同一资源（对象）时起限制作用。

可能大家会说了，那我们有没有办法也限制下这种情况呢，答案当然是可以的。

这就是下面要说的：

2.synchronized修饰静态方法

当修饰静态方法时锁定的是类，而不是对象，我们先把例二修改下看下结果。

例三：

 1 public class TestThread {
 2      public static void main(String[] args){
 3          Mouth m1 = new Mouth();
 4          Mouth m2 = new Mouth();
 5          TestSynchronized s1 = new TestSynchronized(m1);
 6          TestSynchronized s2 = new TestSynchronized(m2); //两个线程访问两个对象
 7          new Thread(s1,"t1").start();
 8          new Thread(s2,"t2").start();
 9      }
10 }
11 
12 class Mouth{
13     synchronized public static void test(){ //改为静态方法，锁定的是类。
14         int ticket = 5;
15         for(int p = 0; p < 10; p++){
16             try {
17                 Thread.sleep(500);
18             } catch (InterruptedException e) {
19                 // TODO Auto-generated catch block
20                 e.printStackTrace();
21             }
22             if(ticket >= 0){
23                 System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
24             }                    
25         }
26     }
27 
28 }
29 
30 class TestSynchronized implements Runnable{
31     private Mouth m = new Mouth();
32     
33     public TestSynchronized(Mouth m){
34         this.m = m;
35     }
36     
37     synchronized public void run(){
38         m.test();
39     }
40 }

运行结果：
t1 ticket:5
t1 ticket:4
t1 ticket:3
t1 ticket:2
t1 ticket:1
t1 ticket:0
t2 ticket:5
t2 ticket:4
t2 ticket:3
t2 ticket:2
t2 ticket:1
t2 ticket:0

当synchronized修饰静态方法时，线程需要获得类（Mouth）锁才能运行，没有获得类锁的线程无法运行，且获得类锁的线程会将synchronized修饰的静态方法会运行完毕才释放类锁。

例如例三中的代码，t1先获得类（Mouth）锁运行Mouth类中的test方法，而t2没有类（Mouth）锁就无法运行。一个类只有一个类锁，却可以有多个对象（t1，t2等...）都是一个类（Mouth）中的对象，只要一个线程获取了类（Mouth）锁，其他线程就要等到类锁被释放，然后获得类（Mouth）锁之后才能运行类（Mouth）中synchronized修饰的静态方法。所以即使是两个线程（t1，t2）访问两个不同的资源（m1，m2）也会受到限制，因为m1，m2都属于一个类（Mouth），而锁住类（Mouth）后每次只能有一个线程访问该类（Mouth）中的sychronized修饰的静态方法。

当t1访问m1中的test时，首先获得类（Mouth）锁，这时如果t2访问m2中的test方法时也需要获得类锁，可是这时类锁已经被线程t1获得，故t2无法访问m2中的方法。只有等t1运行完方法中的内容或异常释放锁后t2才有机会获得锁，获得锁后才能运行。

而之前例一中t1，t2锁的是对象，需要结合这几段代码理解下。

3.synchronized块（也称同步块）

如果每次都锁定的范围都是一个方法，每次只能有一个线程进去势必会导致效率的低下，这主要是锁定范围过多引起的。

这时可以根据实际情况锁定合适的区域，这就要用到同步块了

synchronized（需要锁住的对象或类）{
       
       锁定的部分,需要锁才能运行。
}

（）中可以确定锁定的是对象还是类，锁定对象的话可以用this，对类上锁类名加class，例如要锁定Mounth类（Moutn.class）。

我们首先看个没有任何同步的例子：

 1 public class TestThread {
 2      public static void main(String[] args){
 3          TestSynchronized s1 = new TestSynchronized();
 4     
 5          new Thread(s1,"t1").start();  //两个线程访问一个对象
 6          new Thread(s1,"t2").start();
 7      }
 8 }
 9 
10 class TestSynchronized implements Runnable{
11     private int ticket = 5;
12     
13            public void run(){    
14             for(int p = 0; p < 10; p++){
15                 try {
16                     Thread.sleep(1000);
17                 } catch (InterruptedException e) {
18                     // TODO Auto-generated catch block
19                     e.printStackTrace();
20                 }
21                 if(ticket >= 0){
22                     System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
23                 }                    
24             }
25         }
26 }

运行结果：
t1 ticket:5
t2 ticket:4
t2 ticket:3
t1 ticket:2
t2 ticket:1
t1 ticket:1
t2 ticket:0
t1 ticket:-1

其中出现了-1，我们在其中一块区域加上同步形成同步块。

 1 public class TestThread {
 2      public static void main(String[] args){
 3          TestSynchronized s1 = new TestSynchronized(); //两个线程访问一个对象
 4     
 5          new Thread(s1,"t1").start();
 6          new Thread(s1,"t2").start();
 7      }
 8 }
 9 
10 class TestSynchronized implements Runnable{
11     private int ticket = 5;
12     
13            public void run(){    
14             for(int p = 0; p < 10; p++){
15                 try {
16                     Thread.sleep(1000);
17                 } catch (InterruptedException e) {
18                     // TODO Auto-generated catch block
19                     e.printStackTrace();
20                 }
21                 synchronized(this){  //此次加上同步块，这部分内容一次只有一个线程可以进入，其他内容不受约束。
22                     if(ticket >= 0){ //这里锁的是对象，这里面的内容需要对象锁才能运行。
23                         System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
24                     }
25                 }                    
26             }
27         }
28 }

运行结果：
t2 ticket:5
t1 ticket:4
t1 ticket:3
t2 ticket:2
t1 ticket:1
t2 ticket:0

一次只能有一个线程进入同步块中，就不会出现线程读了未更新的数据或者多减一次的情况。未加synchronized修饰的其他区域不受影响，故两个线程的顺序不定。

下面我们来看一个同步块锁定类的例子，效果和例三一样，只不过例三使用静态方法锁定了类，而下面这个是使用同步块锁定了类。

 1 public class TestThread {
 2     public static void main(String[] args){
 3         TestSynchronized s1 = new TestSynchronized();
 4         TestSynchronized s2 = new TestSynchronized(); //两个线程访问两个对象
 5         new Thread(s1,"t1").start();
 6         new Thread(s2,"t2").start();
 7     }
 8 }
 9 
10 class TestSynchronized implements Runnable{
11    private int ticket = 5;
12    
13    synchronized public void run(){
14        synchronized(TestSynchronized.class){  //将synchronized修饰的静态方法改成了同步块。
15             
16            for(int p = 0; p < 10; p++){
17                try {
18                    Thread.sleep(500);
19                } catch (InterruptedException e) {
20                    // TODO Auto-generated catch block
21                    e.printStackTrace();
22                }
23                if(ticket >= 0){
24                    System.out.println(Thread.currentThread().getName() + " ticket:" + ticket--);
25                }                    
26            }
27        }
28    }
29 }

运行结果：
t1 ticket:5
t1 ticket:4
t1 ticket:3
t1 ticket:2
t1 ticket:1
t1 ticket:0
t2 ticket:5
t2 ticket:4
t2 ticket:3
t2 ticket:2
t2 ticket:1
t2 ticket:0

上述代码和例三功能一样，只是锁定方法不同，这里只是做下演示。

synchronized修饰方法是一种粗颗粒的并发控制，某一时刻只有一个线程执行方法内的内容效率较低下。

synchronized同步块是一种细颗粒的并发控制，可以自行根据需求确定区域较为灵活，可以平衡下效率和安全，同时也能因选择区域不恰当而造成问题。

只要不在synchronized方法（同步块）内的其他部分都不受限制。

普通方法锁定的对象，需要获得对象锁

静态方法锁定的是类，需要获得类锁。

同步块可以确定是锁对象(this )还是锁类（xxx.class），同时也可以自行确定区域。

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Maven项目结合POI导出Excl表格Demo-亲测可用

下一篇：【Java学习】网络编程1

国外程序员整理的Java资源大全（全部是干货） 2020-06-12
2020年深圳中国平安各部门Java中级面试真题合集（附答案） 2020-06-11
2020年java就业前景 2020-06-11
04.Java基础语法 2020-06-11
Java--反射(框架设计的灵魂)案例 2020-06-11

IDC资讯：主机资讯注册资讯托管资讯 vps资讯网站建设

网站运营：建站经验策划盈利搜索优化网站推广免费资源

网站联盟：联盟新闻联盟介绍联盟点评网赚技巧

行业资讯：搜索引擎网络游戏电子商务广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器安全防护

软件技巧：其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识：网络协议网络安全网络管理组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条

最新资讯

热门关注

热门标签