黑马程序员--Java 多线程的安全问题

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

多线程是一种机制,它允许在程序中并发执行多个指令流,每个指令流都称为一个线程,彼此间相互独立线程安全 ,是指变量或方法 (这些变量或方法是多线程共享的)可以在多线程的环境下被安全有效的访问。这说明了两方面的问题：

(1)可以从多个线程中调用,无需调用方有任何操作；

(2)可以同时被多个线程调用,无需线程之不必要的交互。

1. 发现安全隐患：

需求：用Java的多线程模拟火车站的四个售票窗口同时售票

示例代码1：

package
com.itheima.day11;

class Ticket1implements Runnable{

private int
tick = 100;

public void run(){

while(true){

if(tick>0){

System.out.println(Thread.currentThread().getName()+" sale:"+tick--);

}

}

}

}

public class ThreadRunnableDemo {

public static void main(String[] args) {

Ticket1 t = new Ticket1();

Thread t1 =
new Thread(t);

Thread t2 = new Thread(t);

Thread t3 = new Thread(t);

Thread t4 = new Thread(t);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

2. 现象：



从运行结果中发现，发现打印出了：0，-1，-2这样的车票，多线程的运行出现了安全问题

成员变量tick是多个线程共享 的数据

3.问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完

就有另一个线程参与进来执行，导致共享数据的错误

4.解决方案：

对多条操作共享数据的语句，只能让一个线程执行完，在执行过程中，其他线程不可以参与执行

Java中对于多线程的安全问题提供了专业的解决方案：同步代码块

格式：

synchronized(对象){

需要被同步的代码

}

其中的对象是随便可以放的， 该对象如同锁（监视器），持有锁的线程可以在同步中执行，没有翅锁的线程，

即使获得了CPU的执行权，也进不去，因为没有锁

示例代码2：

class Ticket2 implements Runnable{

private inttick = 100;

Object obj = new Object();

public void run(){
//run()方法中全都是线程运行代码，tick为共享数据

while(true){

synchronized(obj){

if(tick>0){

try{

Thread.sleep(10); //此时不能抛出异常，只能用try处理

}catch(Exception e){ }

}

System.out.println(Thread.currentThread().getName()+"..sale:"+tick--);

}

}

}

}

public class ThreadSecurity {

public static void main(String[] args) {

Ticket2 t = new Ticket2();

Thread t1 = new Thread(t);

Thread t2 = newThread(t);

Thread t3 = new Thread(t);

Thread t4 = new Thread(t);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

注意：

必须保证同步只能有一个线程在运行

不是所有的run()中的代码都要进行同步

好处： 解决了多线程的安全问题

弊端： 多个线程需要判断锁，较为消耗资源

5. run()方法中全都是线程运行代码，哪些代码在操作共享数据，则哪些代码就需要被同步

<1>. Thread类中提供了static的 sleep()方法 ，sleep(),单位为millis(毫秒)，

在指定的毫秒数内让当前正在执行的线程休眠

<2>.这个方法会抛出（声明）异常 ，要对其进行处理，处理方式有两种

6. 同步函数的锁（监视器）

<1> .问题：同步函数用的是哪一个锁？

<2>.函数需要被对象调用，那么函数都有一个所属对象的引用，就是this，所以同步函数所使用的锁是this

.<3>.验证：

使用两个线程来卖票：

一个线程在同步代码块中

一个代码在同步函数中

都在执行卖票的动作

如果出现了错误，即就是没有实现同步，若没有错误即实现了同步，也就证明了同步函数的锁就是this

7. 静态同步的锁是Class对象

<1> . 如果同步函数被static修饰后，使用的锁是什么呢？

<2> . 通过验证，发现同步函数被static修饰后锁已经不再是this,(又出现了第0张票的情况，不安全了),因为静态方法中也不可能定义this

<3>. 静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象

即——类名.class 该对象的类型是Class,所以同步代码块中的对象为(Ticket3.class)

<4> . 静态的同步方法，使用的锁是该方法所在类的字节码文件对象，即类名.class

<5> . 只要是用到同步代码块的两个线程用同一个锁，其括号中的锁只要是示例中唯一的所属对象或者唯一的

对象的字节码文件文件，都可以作为对象来使用

示例代码3：

class Ticket3implements Runnable{

private static int
tick = 100;

Object obj = new Object();//任意创建的对象

boolean
flag = true;
//标记

public void run(){
//同步代码块

if(flag){

while(true){

synchronized(Ticket3.class){ //obj锁,换为this

if(tick>0){

try{Thread.sleep(100);}catch(Exception e ){}

System.out.println(Thread.currentThread().getName()+"..code.."+tick--);

//show方法一定被对象调用，所以show()方法之前省略了this,show有所属对象

show();

}

}

}

}else{

while(true)

show();

}

}

public static synchronized void show(){ //同步函数,this锁

if(tick>0){

try{Thread.sleep(10);}catch(Exception e ){}

System.out.println(Thread.currentThread().getName()+"....show...."+tick--);

}

}

}

public class ThreadThisLockDemo {

public static void main(String[] args) {

//此时有3个线程，主线程开启之后，创建对象之后，再开启 t1,t2两个线程

Ticket3 t = new Ticket3();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

//Thread t3 = new Thread(t);

//Thread t4 = new Thread(t);

t1.start(); //开启之后不一定先执行，处于临时状态

//主线程开启之后很有可能将flag和t2直接执行完，主线程已经结束，剩下两个线程t1和t2

try{Thread.sleep(10);}catch(Exception e){} //所以先让主线程停一下（10millis）,此时能运行的只有t1,过了10秒

t.flag = false; //之后主线程被唤醒，然后才会将flag切换为false，再去执行t2

t2.start();

t3.start();

t4.start();

}

}