Java Thread线程使用、线程安全（一）

2018-09-16 本文已影响16人 Kandy_JS

一、参考

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

二、使用场景

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

三、如何使用

1、生命周期

thread_status.jpg

状态	含义	内容
New	新建状态	当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
Runnable	就绪状态	当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
Running	运行状态	当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
Blocked	阻塞状态	处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：
-	等待阻塞	运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
-	同步阻塞	线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
-	其他阻塞	通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
Dead	死亡状态	线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

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()	暂停阻塞等待一段时间，时间过了就继续。 $\color{red}{注意这个是不释放“锁”的 }$
wait()	也是阻塞和等待，但是需要notify来唤醒。 $\color{red}{wait是需要释放“锁”的 }$
join()	在一个线程中调用other.join(),将等待other执行完后才继续本线程
notify()、notifyAll()	唤醒线程
yield()	当前线程可转让cpu控制权，让别的就绪状态线程运行（切换），也会等待阻塞一段时间，但是时间不是由客户控制了
interrupte()	打断线程，代替过时方法stop()
setPriority()	MIN_PRIORITY 最小优先级=1 ， NORM_PRIORITY 默认优先级=5 ，MAX_PRIORITY 最大优先级=10

$\color{red}{sleep 和 wait差别}$

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、保证线程安全的常用方式

方式	含义	原则
lock	锁	重量型（消耗内存较多），原子性，可见的，顺序：公平锁、非顺序：非公平锁
synchronized	同步的，互斥的	重量型（消耗内存较多），原子性，可见的
volitail	易变的	轻量型（消耗内存较少），非原子性，可见的，主要针对共享变量，改变时候其他线程中也随时会改变，但依旧是非原子性的，不是任何场景适合使用

共通部分代码

//不同地方，几乎同一时间向同一个账户保存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 易变的：他可以修饰共享变量，虽然符合【可见性】，但是依旧不是【原子性】，特别是线程中不能使用在对自身进行运算的操作上，但是他消耗内存较小，不会造成阻塞

$\color{red}{使用条件：1、对变量的写操作不依赖于当前值 2、该变量没有包含在具有其他变量的不变式中}$
$\color{red}{不适合：x++ , x--等复合操作}$