Java多线程详解6【面试+工作】

Java多线程详解【面试+工作】

Java线程:新特征-原子量

所谓的原子量即操作变量的操作是“原子的”,该操作不可再分,因此是线程安全的。

为何要使用原子变量呢,原因是多个线程对单个变量操作也会引起一些问题。在Java5之前,可以通过volatile、synchronized关键字来解决并发访问的安全问题,但这样太麻烦。

Java5之后,专门提供了用来进行单变量多线程并发安全访问的工具包java.util.concurrent.atomic,其中的类也很简单。

下面给出一个反面例子(切勿模仿):

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;

/** 
* Java线程:新特征-原子量
* 
* @author leizhimin 2009-11-6 9:53:11 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                Runnable t1 = new MyRunnable("张三", 2000);
                Runnable t2 = new MyRunnable("李四", 3600);
                Runnable t3 = new MyRunnable("王五", 2700);
                Runnable t4 = new MyRunnable("老张", 600);
                Runnable t5 = new MyRunnable("老牛", 1300);
                Runnable t6 = new MyRunnable("胖子", 800);
 //执行各个线程
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                pool.execute(t4); 
                pool.execute(t5); 
                pool.execute(t6); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

class MyRunnableimplements Runnable {
 privatestatic AtomicLong aLong =new AtomicLong(10000);        //原子量,每个线程都可以自由操作
 private String name;                //操作人
 privateint x;                            //操作数额

        MyRunnable(String name, int x) {
 this.name = name;
 this.x = x;
        } 

 publicvoid run() {
   System.out.println(name + "执行了" + x +",当前余额:" + aLong.addAndGet(x));
        } 
}

运行结果:

李四执行了3600,当前余额:13600 王五执行了2700,当前余额:16300 老张执行了600,当前余额:16900 老牛执行了1300,当前余额:18200 胖子执行了800,当前余额:19000 张三执行了2000,当前余额:21000 Process finished with exit code 0

张三执行了2000,当前余额:12000 王五执行了2700,当前余额:18300 老张执行了600,当前余额:18900 老牛执行了1300,当前余额:20200 胖子执行了800,当前余额:21000 李四执行了3600,当前余额:15600 Process finished with exit code 0

张三执行了2000,当前余额:12000 李四执行了3600,当前余额:15600 老张执行了600,当前余额:18900 老牛执行了1300,当前余额:20200 胖子执行了800,当前余额:21000 王五执行了2700,当前余额:18300 Process finished with exit code 0

从运行结果可以看出,虽然使用了原子量,但是程序并发访问还是有问题,那究竟问题出在哪里了?

这里要注意的一点是,原子量虽然可以保证单个变量在某一个操作过程的安全,但无法保证你整个代码块,或者整个程序的安全性。因此,通常还应该使用锁等同步机制来控制整个程序的安全性。

下面是对这个错误修正:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.atomic.AtomicLong;

/** 
* Java线程:新特征-原子量
* 
* @author leizhimin 2009-11-6 9:53:11 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                Lock lock = new ReentrantLock(false);
                Runnable t1 = new MyRunnable("张三", 2000,lock);
                Runnable t2 = new MyRunnable("李四", 3600,lock);
                Runnable t3 = new MyRunnable("王五", 2700,lock);
                Runnable t4 = new MyRunnable("老张", 600,lock);
                Runnable t5 = new MyRunnable("老牛", 1300,lock);
                Runnable t6 = new MyRunnable("胖子", 800,lock);
 //执行各个线程
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                pool.execute(t4); 
                pool.execute(t5); 
                pool.execute(t6); 
 //关闭线程池
                pool.shutdown(); 
        } 
} 

class MyRunnableimplements Runnable {
 privatestatic AtomicLong aLong =new AtomicLong(10000);        //原子量,每个线程都可以自由操作
 private String name;                //操作人
 privateint x;                            //操作数额
 private Lock lock;

        MyRunnable(String name, int x,Lock lock) {
 this.name = name;
 this.x = x;
 this.lock = lock;
        } 

 publicvoid run() {
                lock.lock(); 
                System.out.println(name + "执行了" + x +",当前余额:" + aLong.addAndGet(x));
                lock.unlock(); 
        } 
}

执行结果:

张三执行了2000,当前余额:12000 王五执行了2700,当前余额:14700 老张执行了600,当前余额:15300 老牛执行了1300,当前余额:16600 胖子执行了800,当前余额:17400 李四执行了3600,当前余额:21000 Process finished with exit code 0

这里使用了一个对象锁,来控制对并发代码的访问。不管运行多少次,执行次序如何,最终余额均为21000,这个结果是正确的。

有关原子量的用法很简单,关键是对原子量的认识,原子仅仅是保证变量操作的原子性,但整个程序还需要考虑线程安全的。

Java线程:新特征-障碍器

Java5中,添加了障碍器类,为了适应一种新的设计需求,比如一个大型的任务,常常需要分配好多子任务去执行,只有当所有子任务都执行完成时候,才能执行主任务,这时候,就可以选择障碍器了。

障碍器是多线程并发控制的一种手段,用法很简单。下面给个例子:

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/** 
* Java线程:新特征-障碍器
* 
* @author leizhimin 2009-11-6 10:50:10 
*/ 
publicclass Test {
 publicstaticvoid main(String[] args) {
 //创建障碍器,并设置MainTask为所有定数量的线程都达到障碍点时候所要执行的任务(Runnable)
                CyclicBarrier cb = new CyclicBarrier(7,new MainTask());
 new SubTask("A", cb).start();
 new SubTask("B", cb).start();
 new SubTask("C", cb).start();
 new SubTask("D", cb).start();
 new SubTask("E", cb).start();
 new SubTask("F", cb).start();
 new SubTask("G", cb).start();
        } 
} 

/** 
* 主任务 
*/ 
class MainTask implements Runnable { 
 publicvoid run() {
                System.out.println(">>>>主任务执行了!<<<<");
        } 
} 

/** 
* 子任务 
*/ 
class SubTask extends Thread { 
 private String name;
 private CyclicBarrier cb;

        SubTask(String name, CyclicBarrier cb) { 
 this.name = name;
 this.cb = cb;
        } 

 publicvoid run() {
                System.out.println("[子任务" + name +"]开始执行了!");
 for (int i = 0; i < 999999; i++) ;    //模拟耗时的任务
                System.out.println("[子任务" + name +"]开始执行完成了,并通知障碍器已经完成!");
 try {
 //通知障碍器已经完成
                        cb.await(); 
                } catch (InterruptedException e) {
                        e.printStackTrace(); 
                } catch (BrokenBarrierException e) {
                        e.printStackTrace(); 
                } 
        } 
}

运行结果:

[子任务E]开始执行了! [子任务E]开始执行完成了,并通知障碍器已经完成! [子任务F]开始执行了! [子任务G]开始执行了! [子任务F]开始执行完成了,并通知障碍器已经完成! [子任务G]开始执行完成了,并通知障碍器已经完成! [子任务C]开始执行了! [子任务B]开始执行了! [子任务C]开始执行完成了,并通知障碍器已经完成! [子任务D]开始执行了! [子任务A]开始执行了! [子任务D]开始执行完成了,并通知障碍器已经完成! [子任务B]开始执行完成了,并通知障碍器已经完成! [子任务A]开始执行完成了,并通知障碍器已经完成! >>>>主任务执行了!<<<< Process finished with exit code 0

从执行结果可以看出,所有子任务完成的时候,主任务执行了,达到了控制的目标。

面试题:

Java中创建线程主要有三种方式:

一、继承Thread类创建线程类

(1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

(2)创建Thread子类的实例,即创建了线程对象。

(3)调用线程对象的start()方法来启动该线程。

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

二、通过Runnable接口创建线程类

(1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。

(2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

(3)调用线程对象的start()方法来启动该线程。

示例代码为:

三、通过Callable和Future创建线程

(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。

(2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。

(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。

(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

实例代码:

二、创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时,优势是:

线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。

在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

劣势是:

编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时优势是:

编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。

劣势是:

线程类已经继承了Thread类,所以不能再继承其他父类。

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2017-12-12

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Java架构沉思录

优雅实现延时任务之zookeeper篇

在《优雅实现延时任务之Redis篇》一文中提到,实现延时任务的关键点,是要存储任务的描述和任务的执行时间,还要能根据任务执行时间进行排序,那么我们可不可以使用z...

40130
来自专栏菩提树下的杨过

java学习:JMM(java memory model)、volatile、synchronized、AtomicXXX理解

一、JMM(java memory model)内存模型 从网上淘来二张图: ? 上面这张图说的是,在多核CPU的系统中,每个核CPU自带高速缓存,然后计算机主...

214100
来自专栏分布式系统进阶

Kafka中的时间轮Kafka源码分析-汇总

将TimerTask对象绑定到 TimerTaskEntry上 如果这个TimerTask对象之前已经绑定到了一个 TimerTaskEntry上, 先调用t...

22610
来自专栏吴伟祥

四种任务调度的 Java 实现 转

 java.util.Timer 了,它是最简单的一种实现任务调度的方法,下面给出一个具体的例子:

12610
来自专栏无题

JAVA多线程构件(java.util.concurrent包下高级工具)

Java1.5提供了一个非常高效实用的多线程包:java.util.concurrent, 提供了大量高级工具,可以帮助开发者编写高效、易维护、结构清晰的Jav...

1.1K70
来自专栏雨尘分享

5.Block的内存管理 内存管理内存管理block的循环引用

18140
来自专栏Spark学习技巧

java线程池模型

一, 线程池与普通线程 1 普通线程 Java实现多线程,常见的有以下三种方式: 1 继承Thread,重写该类的run()方法 2 实现Runnable 实现...

22570
来自专栏深入浅出区块链技术

智能合约语言 Solidity 教程系列9 - 错误处理

这是Solidity教程系列文章第9篇介绍Solidity 错误处理。 Solidity系列完整的文章列表,可阅读原文,查看分类-Solidity。

14250
来自专栏Golang语言社区

GO语言标准库概览

在Go语言五周系列教程的最后一部分中,我们将带领大家一起来浏览一下Go语言丰富的标准库。 Go标准库包含了大量包,提供了丰富广泛的功能特性。这里提供了概览仅仅是...

29040
来自专栏小勇DW3

LockSupport的源码实现原理以及应用

如果只是LockSupport在使用起来比Object的wait/notify简单,

27920

扫码关注云+社区

领取腾讯云代金券