1.线程的生命周期

2.线程安全和同步代码块synchronized()

synchronized(锁){ 操作共享数据的代码 }//保证线程安全

1. 锁默认打开，有一个线程进去了，锁自动关闭。
2. 里面的代码全部执行完毕，线程出来，锁自动打开

package threadSafe;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class demo {
    public static void main(String[] args) {
        /*
        * 三个窗口售卖一百张票
        * */
        //创建线程对象
        mythread t1=new mythread("窗口1");
        mythread t2=new mythread("窗口2");
        mythread t3=new mythread("窗口3");

        //开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

static int ticket=0;//对象共享成员变量数据
//创建锁对象，static保证唯一
static Object obj=new Object();

package threadSafe;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class mythread extends Thread{
    static int ticket=0;//对象共享成员变量数据

    //创建锁对象，static保证唯一
    static Object obj=new Object();
    public mythread() {
    }

    public mythread(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if(ticket<100){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+"正在卖第"+ticket+"张票");
                }else{
                    break;
                }
            }
        }
    }
}

3.Lock锁

//Lock是接口不能直接实例化，这里采用他的实现类ReentrantLock来实例化
//void lock;获得锁；
//void unlock;释放锁；

package threadLock;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class demo02 {
    public static void main(String[] args) {
        /*
        * 三个窗口售卖一百张票
        * */
        //创建线程对象
        mythread02 t1=new mythread02("窗口1");
        mythread02 t2=new mythread02("窗口2");
        mythread02 t3=new mythread02("窗口3");

        //开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

static Lock lock=new ReentrantLock();//static获得唯一的锁对象

package threadLock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @version 1.0
 * @auther Demo龙
 */
public class mythread02 extends Thread{
    static int ticket=0;//对象共享成员变量数据

    //Lock是接口不能直接实例化，这里采用他的实现类ReentrantLock来实例化
    //void lock;获得锁；
    //void unlock;释放锁；
    static Lock lock=new ReentrantLock();//static获得唯一的锁对象

    public mythread02() {
    }
    public mythread02(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if(ticket<100){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+"正在卖第"+ticket+"张票");
                }else{
                    break;
                }
            } catch (RuntimeException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }

        }
    }
}