Java 进阶(11) 线程安全

为什么会出现线程安全问题？

线程不安全：

当多线程并发访问临界资源时，如果破坏原⼦操作，可能会造成数据不⼀致。

临界资源：共享资源（同⼀对象），⼀次仅允许⼀个线程使⽤，才可保证其正确性。

原子操作：不可分割的多步操作，被视作⼀个整体，其顺序和步骤不可打乱或缺省。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，⽽⽆写操作，⼀般来说，这个全局变量是线程安全的；若有多个线程同时执⾏写操作，⼀般都需要考虑线程同步，否则的话就可能影响线程安全。

示例：

class TicketRunnable implements Runnable{
    private int ticket=100;
    //每个窗⼝卖票的操作
    //窗⼝ 永远开启
    @Override
    public void run() {
        while(true){//有票可以卖
            //出票操作
            if(ticket > 0){
                //使⽤sleep模拟⼀下出票时间 //模拟⼀下出票的时间
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖票："+ticket--);
            }
        }
    }
}
public class ThreadSafe {
    public static void main(String[] args) throws Exception{
        TicketRunnable t = new TicketRunnable();
        Thread t1 = new Thread(t,"窗⼝1");
        Thread t2 = new Thread(t,"窗⼝2");
        Thread t3 = new Thread(t,"窗⼝3");
        //3个窗⼝同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

为了保证每个线程都能正常执⾏原⼦操作,Java引⼊了线程同步机制。那么怎么去使⽤呢？有三种⽅式完成同步操作：

1. 同步代码块。

2. 同步⽅法。

3. 锁机制。

同步代码块

语法：

synchronized(临界资源对象){ //对临界资源对象加锁
    //代码（原⼦操作）
}

同步锁:

对象的同步锁只是⼀个概念,可以想象为在对象上标记了⼀个锁.

1. 锁对象 可以是任意类型。

2. 多个线程对象 要使⽤同⼀把锁。

注意: 在任何时候,最多允许⼀个线程拥有同步锁,谁拿到锁就进⼊代码块,其他的线程只能在外等着(BLOCKED)。

示例：

class Ticket2 implements Runnable{
    private int ticket=100;
    Object lock = new Object();
    //每个窗⼝卖票的操作
    //窗⼝ 永远开启
    @Override
    public void run() {
        while(true){//有票可以卖
            synchronized(lock){//synchronized (this) {//this ---当前对象
                if(ticket>0){
                    //出票操作
                    //使⽤sleep模拟⼀下出票时间
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖票："+ticket--);
                }
            }
        }
    }
}
public class TicketDemo2 {
    public static void main(String[] args) {
        Ticket2 ticket2 = new Ticket2();
        Thread t1 = new Thread(ticket2,"窗⼝1");
        Thread t2 = new Thread(ticket2,"窗⼝2");
        Thread t3 = new Thread(ticket2,"窗⼝3");
        //3个窗⼝同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法

同步方法 : 使⽤synchronized修饰的⽅法,就叫做同步⽅法,保证A线程执⾏该⽅法的时候,其他线程只能在⽅法外等着。

语法：

synchronized 返回值类型 ⽅法名称(形参列表){ //对当前对象（this）加锁
// 代码（原⼦操作）
}

只有拥有对象互斥锁标记的线程，才能进⼊该对象加锁的同步⽅法中。

线程退出同步⽅法时，会释放相应的互斥锁标记。

如果方式是静态，锁是类名.class。

示例：

class Ticket3 implements Runnable{
    private int ticket=100;
    //Object lock = new Object();
    //每个窗⼝卖票的操作
    //窗⼝ 永远开启
    @Override
    public void run() {
        while(true){//有票可以卖
            sellTicket();
            if(ticket<=0){
                break;
            }
        }
    }
    /**
    * 锁对象，谁调⽤这个⽅法，就是谁
    * 隐含锁对象，就是this
    * 静态⽅法，隐含锁对象就是Ticket3.class
    */
    public synchronized void sellTicket(){
        if(ticket>0){
        //出票操作
        //使⽤sleep模拟⼀下出票时间
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"正在卖票："+ticket--);
        }
    }
}
public class TicketDemo3 {
    public static void main(String[] args) {
        Ticket3 ticket3 = new Ticket3();
        Thread t1 = new Thread(ticket3,"窗⼝1");
        Thread t2 = new Thread(ticket3,"窗⼝2");
        Thread t3 = new Thread(ticket3,"窗⼝3");
        //3个窗⼝同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

 

synchronized注意点

同步锁是谁?

对于⾮static⽅法,同步锁就是this。

对于static方法,我们使⽤当前方法所在类的字节码对象(类名.class)。

Lock

JDK5加⼊，与synchronized⽐较，显示定义，结构更灵活。

提供更多实⽤性⽅法，功能更强⼤、性能更优越。

常用方法：

方法名	描述
void lock()	获取锁，如锁被占⽤，则等待。
boolean tryLock()	尝试获取锁（成功返回true。失败返回false，不阻塞）。
void unlock()	释放锁。

ReentrantLock：

Lock接⼝的实现类，与synchronized⼀样具有互斥锁功能。

示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyList {
    //创建锁
    private Lock lock = new ReentrantLock();
    private String[] str = {"A","B","","",""};
    private int count = 2;
    public void add(String value){
        //当没有锁的时候，会出现覆盖的情况
        str[count] = value;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count++;
        System.out.println(Thread.currentThread().getName()+"添加了"+value);
    }
    public String[] getStr(){
        return str;
    }
}

测试： 

public class TestMyList {
    public static void main(String[] args) throws InterruptedException {
        MyList myList = new MyList();
        Thread t1 =new Thread(new Runnable() {
            @Override
            public void run() {
                myList.add("hello");
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                myList.add("world");
            }
        });
        t2.start();
        t1.join();
        t2.join();
        String[] str = myList.getStr();
        for (String s : str) {
            System.out.println("s:"+s);
        }
    }
}