多线程访问产生的临界资源问题

有多个线程在同时访问一个资源，如果一个线程在取值的过程中，时间片又被其他线程抢走了，临界资源问题就产生了。

比如在《多线程——基础使用》中的存钱和取钱的案例，当存钱加和操作执行完毕，还没有执行打印操作的时候，取钱线程进入，并将钱取走，先一步打印，这样的输出结果就会有问题：余额为0，但是取走了1000。

解决方案：一个线程在访问临界资源的时候，给这个资源“上一把锁”，这个时候如果其他线程也要访问这个资源，就得在“锁”外面等待，直到该线程执行完毕，释放锁。

同步代码块

同步：Synchronized：有等待

异步：Asynchronized：没有等待，各执行各的

/*** 注意事项：* 1.程序走到代码段中，就用锁来锁住了临界资源，这个时候，其他线程不能执行代码段中的代码，只能在锁外边等待* 2.执行完代码段中的这段代码，会自动解锁。然后剩下的其他线程开始争抢cpu时间片* 3.一定要保证不同的线程看到的是同一把锁，否则同步代码块没有意义，也就是说mutex的值必须是唯一的，不能new对象，一般使用字符串或者 对象.Class()方法* 4.使用同步代码块，必须是真正意义上存在的线程直接抢占系统共享资源，而且同步的代码越少越好，提高效率* 5.避免死锁情况发生*  * 死锁发生的条件：* 1.有两个以上线程抢占资源* 2.至少有两个锁* 3.锁同步中嵌套锁同步*/synchronized(mutex) {
   	//需要加锁的代码块，不要将循环放入，否则会出现一个线程一直循环占用资源而不释放锁}//案例class Tickets implements Runnable {
       private static int tickets = 100;    private int flag = 0;    @Override    public void run() {
           while (true) {
               synchronized ("lock") {
                   if (tickets > 0) {
                       System.out.println(Thread.currentThread().getName() +                            "已经卖出了" + ++flag + "张票, " + "还剩余" + (tickets - 1) + "张票");                    try {
                           Thread.sleep(100);                    } catch (InterruptedException e) {
                           e.printStackTrace();                    }                    tickets--;                } else {
                       System.out.println("售罄");                    break;                }            }        }    }}

同步方法

将一个方法使用synchronized修饰，然后由线程直接调用该方法，一般分为非静态同步方法和静态同步方法。

非静态同步方法，由于是new的对象调用的，意味着不同的对象调用的锁不一样，所以使用线程调用的时候，注意对象地址的统一。

静态同步方法可以避免“不同锁”的情况。

public class Demo2 {
       private static int tickets = 100;    //静态同步方法    public static synchronized void saleTickets() throws InterruptedException {
           if (tickets == 0) {
               System.out.println("售罄");        } else {
               System.out.println(Thread.currentThread().getName() +             "售出后,剩余" + (tickets - 1) + "张票");            tickets--;            Thread.sleep(100);        }    }		//主方法，使用了匿名内部类调用静态方法    public static void main(String[] args) {
           new Thread(() -> {
               while (tickets > 0) {
                   try {
                   	//调用同步方法                    saleTickets();                } catch (InterruptedException e) {
                       e.printStackTrace();                }            }        }, "糯米").start();        new Thread(() -> {
               while (tickets > 0) {
                   try {
                       saleTickets();                } catch (InterruptedException e) {
                       e.printStackTrace();                }            }        }, "美团").start();    }}

ReentrantLock类(可重入锁)

从jdk1.5之后加入新的接口 Lock，ReentrantLock是Lock接口的实现类。

通过显式定义同步锁对象来实现同步,同步锁提供了比synchronized代码块更广泛的锁定操作，使用ReentrantLock可以显式地加锁、释放锁。

注意：锁后使用try-finally结构，unlock的操作放到finally中，注意对象地址的一致性

//主方法public class Demo1 {
       public static void main(String[] args) {
       	//不建议使用匿名内部类，每次都是新建Tickets对象，如果锁没有static final修饰，会出现不同锁问题        new Thread(new Tickets(), "猫眼").start();        new Thread(new Tickets(), "淘票票").start();        new Thread(new Tickets(), "糯米").start();        new Thread(new Tickets(), "百度").start();    }}//继承Runnable的票类class Tickets implements Runnable {
       private static int tickets = 100;    private int flag = 0;    //定义锁的对象,由于对象地址的不确定性，可能导致new不同对象，锁不同，所以这里使用static final修饰    private static final Lock lock = new ReentrantLock();    @Override    public void run() {
           while (true) {
               //上锁            lock.lock();            try {
                   if (tickets > 0) {
                       System.out.println(Thread.currentThread().getName() +                            "已经卖出了" + ++flag + "张票, " + "还剩余"                             + (tickets - 1) + "张票");                    tickets--;                } else {
                       System.out.println("售罄");                    break;                }            } finally {
                   //手动解锁                lock.unlock();            }        }    }}

转载地址：http://nxgzi.baihongyu.com/

你可能感兴趣的文章