解决线程安全问题-Lock锁和线程状态概述

解决线程安全问题-Lock锁

java.util.concurrent.locks.Lock`机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,

同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

　　Lock锁也称同步锁，加锁与释放锁方法化了，如下:

　　　　public void lock():加同步锁。

　　　　public void unlock():释放同步锁。

解决线程安全问题的三种方案:使用Lock锁java.util.concurrent.locks.Lock接口

Lock实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作。

lock接口中的方法:

　　void lock()获取锁。

　　void unLock()释放锁。

java.util.concurrent.Locks.ReentrantLock impLements Lock接口

使用步骤:

　　1.在成员位置创建一个Reentrantlock对象l　　

　　2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁

　　3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁

public class RunnableImpl implements Runnable{
    
    Lock l =  new ReentrantLock();
    private int ticket = 100;
    //设置线程任务:卖票

    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行while(true){
        //先判断票是否存在
        while (true){

            l.lock();
                if(ticket>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //票存在,卖票ticket--
                    System.out .println(Thread.currentThread( ).getName()+"-->正在卖第" +ticket+"张票"+ticket--);
                }
            l.unlock();
            }
    }
}

public class RunnableImpl implements Runnable{

    Lock l =  new ReentrantLock();
    private int ticket = 100;
    //设置线程任务:卖票

    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行while(true){
        //先判断票是否存在
        while (true){

            l.lock();
                if(ticket>0){
                    try {
                        Thread.sleep(10);
                        //票存在,卖票ticket--
                        System.out .println(Thread.currentThread( ).getName()+"-->正在卖第" +ticket+"张票"+ticket--);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        l.unlock();
                    }
                }
            }
    }
}

 public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread thread = new Thread(runnable);
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

        thread.start();
        thread1.start();
        thread2.start();
    }

 

线程状态概述

线程的六种状态

线程一共有六种状态。就是六种，
1.NEW 
2.RUNNABLE 
3.BLOCKED 
4.WAITING 
5.TIMED_WAITING 
6.TERMINATED 
 
下面分别说明下各种状态情况
1.NEW  线程创建完但未调用 start方法
 
2.RUNNABLE 可细分两种情况  
    1. 线程正在Java虚拟机中执行 
    2. 等待操作系统分配资源(例如CPU时间片)
 
3.BLOCKED 可细分两种情况：
    1. 准备进入synchronized修饰的代码块或方法，等待对象监视器锁 
    2. 已进入synchronized修饰的代码块或方法中并调用了Object.wait()方法
 
4.WAITING 有由一下三种情况触发
    1. Object.wait() 没有设置timeout(区别于 Object.wait(long timeout))
    2. thread.join() 没有设置timeout (区别于 thread.join(long timeout))
    3. LockSupport.park
 
5.TIMED_WAITING 线程指定了定时等待状态。有以下五种情况：
    1. 调用Thread.sleep
    2. Object.wait(long timeout) (这里区别于Object.wait(),有超时时间)
    3. thread.join(long) (这里区别于Thread.join(),有超时时间)
    4. LockSupport.parkNanos
    5. LockSupport.parkUntil
 
6.TERMINATED 线程执行完成。