Java Thread线程使用、线程安全(一)

  1. 云栖社区>
  2. 博客>
  3. 正文

Java Thread线程使用、线程安全(一)

kandy_aliyq 2018-09-16 21:42:00 浏览438
展开阅读全文

一、参考

1、java中的线程安全
2、Java总结篇系列:Java多线程(一)

二、使用场景

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

三、如何使用

1、生命周期
img_90f26580297a213b4f82bf4dfe37d680.jpe
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--等复合操作}

网友评论

登录后评论
0/500
评论
kandy_aliyq
+ 关注