一、参考

1、java中的线程安全
2、Java总结篇系列：Java多线程（一）

二、使用场景

1、耗时的操作使用线程（异步操作），提高应用程序响应
2、并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求（多线程）。
3 、多CPU系统中，使用线程提高CPU利用率
4、改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

三、如何使用

1、生命周期

thread_status.jpg

2、创建启动

已知Thread是实现Runable接口的，最终Runable中的run()方法才是最终需要执行的内容

2.1、新建Runable类实例，创建Thread时候入参Runable，这时候会执行Thread的init方法，会把此Runable变为Thread的一个Runable的类变量target
部分源码

/* What will be run. */
private Runnable target;

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

@Override
    public void run() {
        if (target != null) {
            target.run();
       }
}

启动，结果是：runable running

/**
 * print: runable running
 * */
private Runnable myRun = new Runnable() {
        @Override
        public void run() {
            ComUtil.print("runable running");
        }
};

Thread a = new Thread(myRun);
a.start();

2.2、新建自定义Thread类，然后复写run方法，那么如果此时创建的时候还入参一个runnable对象会怎么样呢？
启动，结果：thread running ， 虽然入参了变成Thread里的target了，可是此thread复写了Runable接口的run方法，所有不走父类的run了，直接走子类。如果还想走父类的run，那么在run方法里面写：super.run();

/**
     * print: thread running
     * */
    private Thread myThread = new Thread(myRun){
        @Override
        public void run() {
            ComUtil.print("thread running");
        }
    };

2.3、使用Callable和Future接口创建线程。。。

3、常用方法

方法	含义
sleep()	暂停阻塞等待一段时间，时间过了就继续。
wait()	也是阻塞和等待，但是需要notify来唤醒。
join()	在一个线程中调用other.join(),将等待other执行完后才继续本线程
notify()、notifyAll()	唤醒线程
yield()	当前线程可转让cpu控制权，让别的就绪状态线程运行（切换），也会等待阻塞一段时间，但是时间不是由客户控制了
interrupte()	打断线程，代替过时方法stop()
setPriority()	MIN_PRIORITY 最小优先级=1 ， NORM_PRIORITY 默认优先级=5 ，MAX_PRIORITY 最大优先级=10

public void testSleepAndWait(){
        Thread t1 = new Thread(run1);
        t1.start();
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t2 = new Thread(run2);
        t2.start();
    }

    private Runnable run1 = new Runnable() {
        @Override
        public void run() {
            synchronized (ThreadTest.class){
                ComUtil.print("run_1 ready and waiting...");
                try {
                    //等待阻塞，等唤醒，如果不换型，就一直挂着
                    //然后释放锁，让给其他线程使用
                    ThreadTest.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ComUtil.print("run_1 running...");
                ComUtil.print("run_1 dead");
            }
        }
    };

    private Runnable run2 = new Runnable() {
        @Override
        public void run() {
            synchronized (ThreadTest.class){
                ComUtil.print("run_2 ready");
                ComUtil.print("run_2 running and sleep...");
                //唤醒阻塞的线程，重新进入监视锁状态，并准备抢锁
                ThreadTest.class.notify();
                //不释放锁，仅仅睡一会，一会继续
                //直到完成，锁才让给其他等待运行的线程
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ComUtil.print("run_2 dead");

            }
        }
    };

1、加入wait的唤醒,notify，运行结果如下

run_1 ready and waiting...
run_2 ready
run_2 running and sleep...
run_2 dead
run_1 running...
run_1 dead

2、注释掉notify

run_1 ready and waiting...
run_2 ready
run_2 running and sleep...
run_2 dead

四、线程安全

1、一般说线程安全需要符合【原子性】和【可见性】和【顺序的】，那么使用多线程时候如果稍有不注意，很多操作就是非原子性的，会导致一些问题。

EG：最常见的一个案例：同一个时间，银行三个柜台同时向一个账户存钱，因为线程间是不能互相传递数据的，这就导致操作同一个共享对象的内存在某个线程改变时候，在其他线程不会随时更新，就会导致一个问题。

2、保证线程安全的常用方式

共通部分代码

//不同地方，几乎同一时间向同一个账户保存10，20，70，总共100元
    public void save(){
        new Thread(){
            @Override
            public void run() {
                saveMoney(1,10,this.getName());
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                saveMoney(2,20,this.getName());
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                saveMoney(3,70,this.getName());
            }
        }.start();

        try {
            Thread.sleep(1000);
            ComUtil.print("最后账户="+mAcount);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

1、Lock 锁：那个线程先抢到锁，其他线程调用到此方法时候休眠，直到这个线程释放锁，其他线程能继续运行此方法

ReentrantLock 有机会再好好讲一下

private Lock lock = new ReentrantLock();//注意这个地方
private void saveMoney(int time,int money,String tName){
        lock.lock();
        try {
            Thread.sleep(100);
            mAcount += money;
            ComUtil.print("线程："+tName+"，第【"+time+"】次存钱，账户="+mAcount);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

结果：原子的，可见的，顺序：公平锁 、非顺序：非公平锁
线程：Thread-1，第【1】次存钱，账户=10
线程：Thread-2，第【2】次存钱，账户=30
线程：Thread-3，第【3】次存钱，账户=100
最后账户=100

2、synchronized 同步的，互斥的： 1、同步代码块，非静态同步，同步当前实例 2、同步代码块，静态同步，同步类.class 3、还可以修饰方法

private void saveMoney(int time,int money,String tName){
        synchronized (this){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mAcount += money;
            ComUtil.print("线程："+tName+"，第【"+time+"】次存钱，账户="+mAcount);
        }

    }

    private synchronized void saveMoney(int time,int money,String tName){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mAcount += money;
            ComUtil.print("线程："+tName+"，第【"+time+"】次存钱，账户="+mAcount);

    }

结果：原子的，可见的，非顺序的
线程：Thread-1，第【1】次存钱，账户=10
线程：Thread-3，第【3】次存钱，账户=80
线程：Thread-2，第【2】次存钱，账户=100
最后账户=100

3、volatile 易变的：他可以修饰共享变量，虽然符合【可见性】，但是依旧不是【原子性】，特别是线程中不能使用在对自身进行运算的操作上，但是他消耗内存较小，不会造成阻塞