java线程安全之同步函数和同步代码块

 

今天在复习java的知识的时候看到了线程解决安全问题的两种方式，同步函数和同步代码块。

多线程出现安全问题的原因：

a)        多个线程在操作共享数据

b)       操作共享数据的代码有多条

当一个线程在执行多条操作共享数据的过程中，其他线程参与了运算，这时就会发生安全问题。

故而，分析多线程安全的依据就是：

1，线程任务中有没有共享数据；

2，该数据是否被多条语句操作。

 

首先我们得明白两个概念：同步 和 互斥；

同步——这是线程 or  进程之间的 合作关系。对多个线程在执行次序上进行协调，以使并发的各个线程能更好的利共享资源，相互合作。多个线程之间，一个线程需要等待另一个线程执行完毕后才能继续执行。 如：下文中，当一个线程拿到锁没有释放之前另一个线程不能执行，只能是等待上个线程 释放了锁之后才能执行。

 

互斥——这是线程 or  进程之间的 竞争关系。在生产者消费者的例子中，当有生产者在写的时候，消费者就不能读，他们在竞争 缓冲区。

只要 保证一个线程在执行多条操作共享数据的语句时，其他线程不能参与运算即可。

当该线程都执行完后，其他线程才可以执行这些语句。

Java为我们提供了具体的解决方案——同步代码块。

synchronized（对象）{ // 对象可以是 任意的对象

//需要被同步的代码；

}

在上个例子中加入synchronized 后，代码如下：

01.package chapter1502;  
02.  
03.public class Ticket1 implements Runnable{  
04.    private int tickets = 100;  
05.      
06.    private Object obj = new Object();  
07.    //线程任务  
08.    public void run(){  
09.        while(true){  
10.            synchronized(obj){ //加锁  
11.                if(tickets>0){  
12.                    try {  
13.                        Thread.sleep(10);  
14.                    } catch (InterruptedException e) {  
15.                        // TODO Auto-generated catch block  
16.                        e.printStackTrace();  
17.                    }  
18.                    System.out.println(Thread.currentThread().getName() + "    " + tickets--);  
19.                }             
20.            }  
21.        }  
22.    }  
23.}  

至此，就解决了 上篇所提及的 线程安全问题！

下面介绍三个问题：同步的原理，同步的好处,弊端 ，同步的前提

同步的原理：其实就是将需要同步的代码进行封装，并在该代码上加了一个锁。

同步的好处，弊端：

好处：使多线程处于能够安全的运行。

弊端：在加了多线程之后，多个线程在对锁申请使用权的时候，会使CPU不断的切换，，这样做，会引起性能的降低。

同步的前提：

1. 必须要保证在同步中有多个线程。      因为同步中只有一个线程该同步是没有意义的。

2. 必须要保证多个线程在同步中使用的是同一个锁。这是才称为 多个线程被同步了！

关于同步的前提，请看下例代码：

 

01.package chapter1502;  
02.  
03.public class Ticket1 implements Runnable{  
04.    private int tickets = 100;  
05.      
06.    //线程任务  
07.    public void run(){  
08.        Object obj = new Object();  
09.        while(true){  
10.            synchronized(obj){ //加锁  
11.                if(tickets>0){  
12.                    try {  
13.                        Thread.sleep(10);  
14.                    } catch (InterruptedException e) {  
15.                        // TODO Auto-generated catch block  
16.                        e.printStackTrace();  
17.                    }  
18.                    System.out.println(Thread.currentThread().getName() + "    " + tickets--);  
19.                }             
20.            }  
21.        }  
22.    }  
23.}  

[java] view plaincopyprint?
01.public class SaleTicket2 {  
02.  
03.    public static void main(String[] args) {  
04.        //任务对象  
05.        Ticket1 t1 = new Ticket1();  
06.        //线程对象  
07.        Thread td1 = new Thread(t1);  
08.        Thread td2 = new Thread(t1);  
09.        Thread td3 = new Thread(t1);  
10.        Thread td4 = new Thread(t1);  
11.          
12.        //开启线程  
13.        td1.start();  
14.        td2.start();  
15.        td3.start();  
16.        td4.start();  
17.    }  
18.}  

运行后发现，即使加了同步 ，加了锁，然而问题依旧，这是为什么呢？

在主函数中：

//任务对象
Ticket1 t1 = new Ticket1();
//线程对象
Thread td1 = new Thread(t1);
Thread td2 = new Thread(t1);
Thread td3 = new Thread(t1);
Thread td4 = new Thread(t1);

//开启线程
td1.start();
td2.start();
td3.start();
td4.start();

 

当我们在主函数中，创建了线程对象后，注意，每个run()方法中，都有一个锁，因为他们自己用的自己的锁，所以 同步就相当于没加，所以会再次出现这样的问题，故而，当我们在为同步加锁的时候，一定得保证，加的锁是同一把锁。

同步函数：函数本身没有同步性，当我们为他加上 synchronized标记后，他也就具备了同步性。

上述代码经过修改后：

[java] view plaincopyprint?
01.class Ticket implements Runnable  
02.{  
03.    private int num = 100;  
04.    private Object obj = new Object();  
05.    public  void run()  
06.    {  
07.        while(true)  
08.        {  
09.            show();  
10.        }  
11.    }  
12.    //同步函数  
13.    public synchronized void show()  
14.    {  
15.        if(num>0)  
16.        {  
17.            try{Thread.sleep(10);}catch(InterruptedException e){}  
18.            System.out.println(Thread.currentThread().getName()+".....sale....."+num--);  
19.        }  
20.    }  
21.}  
22.class TicketDemo3   
23.{  
24.    public static void main(String[] args)   
25.    {  
26.        Ticket t = new Ticket();  
27.          
28.        //创建线程对象。  
29.          
30.        Thread t1 = new Thread(t);  
31.        Thread t2 = new Thread(t);  
32.        Thread t3 = new Thread(t);  
33.        Thread t4 = new Thread(t);  
34.  
35.        t1.start();  
36.        t2.start();  
37.        t3.start();  
38.        t4.start();  
39.  
40.    }  
41.}  

那么，同样是同步，同步函数和同步代码块的区别：

1. 同步函数比同步代码块 写法简单。

2. 同步函数使用的锁是 this . 同步代码块使用的是 任意指定的对象。

下面主要介绍一下，锁——同步代码块，同步函数，静态同步函数使用的锁：

1. 同步代码块使用的锁是：任意的对象；

2. 同步函数使用的锁是： this , this代表当前对象的引用。

3. 静态——当一个类被加载进内存以后，在我们还没有创建对象的时候，已经有对象了Xx.class。

静态随着类的加载而加载，这时内存中存储的对象至少有一个  就是该类字节码文件对象。

这个对象的表示方式： 类名.class 

01.class StaticLockDemo   
02.{  
03.    public static void main(String[] args)   
04.    {  
05.        Ticket t = new Ticket();  
06.          
07.        //创建线程对象。  
08.          
09.        Thread t1 = new Thread(t);  
10.        Thread t2 = new Thread(t);  
11.  
12.        t1.start();  
13.        try{Thread.sleep(10);}catch(InterruptedException e){}  
14.        //在开启了t1后，将标记置为false。  
15.        t.setFlag();  
16.  
17.        t2.start();  
18.  
19.  
20.    }  
21.}  
22.  
23.class Ticket implements Runnable  
24.{  
25.    private static  int num = 200;  
26.    private boolean flag = true;  
27.    public  void run()  
28.    {  
29.        if(flag)//为true就执行同步代码块。  
30.            while(true)  
31.            {  
32.                synchronized(Ticket.class)  
33.                {  
34.                    if(num>0)  
35.                    {  
36.                        try{Thread.sleep(10);}catch(InterruptedException e){}  
37.                        System.out.println(Thread.currentThread().getName()+".....code.........."+num--);  
38.                    }  
39.                }  
40.            }  
41.        else//为false就执行同步函数。   
42.            while(true)  
43.            {  
44.                show();  
45.            }  
46.    }  
47.    /* 
48.    将标记改为false。 
49.    */  
50.    public void setFlag()  
51.    {  
52.        flag = false;  
53.    }  
54.  
55.    public static synchronized void show()  
56.    {  
57.        if(num>0)  
58.        {  
59.            try{Thread.sleep(10);}catch(InterruptedException e){}  
60.            System.out.println(Thread.currentThread().getName()+"............func....."+num--);  
61.        }  
62.    }  
63.}  
64.  
65.class StaticLockDemo   
66.{  
67.    public static void main(String[] args)   
68.    {  
69.        Ticket t = new Ticket();  
70.          
71.        //创建线程对象。  
72.          
73.        Thread t1 = new Thread(t);  
74.        Thread t2 = new Thread(t);  
75.  
76.        t1.start();  
77.        try{Thread.sleep(10);}catch(InterruptedException e){}  
78.        //在开启了t1后，将标记置为false。  
79.        t.setFlag();  
80.  
81.        t2.start();  
82.  
83.    }  
84.}  

                                                                           ------- android培训、java培训、IOS培训、.Net培训期待与您交流！ ----------