文档章节

Java并发编程,并发基础

郑加威
 郑加威
发布于 2018/03/01 19:29
字数 2117
阅读 192
收藏 13

java从诞生之日起,就明智的选择了内置对多线程的支持。

几个概念

在开始写并发之前,先介绍几个简单的概念:

  • 并发和并行: 并发指多个任务交替的执行,并行指多个任务同时执行
  • 临界区:表示一种公共资源或者共享数据,一次只能有一个线程访问它
  • JMM的特性: 原子性,可见性,有序性

程序、进程、线程

  • 程序:具有某些功能的代码。
  • 进程:操作系统进行资源分配和资源调度的基本单位。进程是程序执行的实体。
  • 线程:轻量级的进程,程序执行的最小单位,线程中含有独立的计数器,堆栈和局部变量等属性,必须拥有一个父进程,并且共享进程中所拥有的全部资源。

进程之间不能共享内存,线程共享内存非常容易。

线程的状态
线程是有生命周期的,生命周期的状态如下:

  • NEW :新建
  • READY:就绪
  • RUNNABLE : 运行
  • BLOCKED :阻塞
  • WAITING : 等待
  • TIME_WAITING:超时等待
  • TERMINATED : 终止

Java程序中的线程在自身的生命周期中,并不是固定地处于某个状态,而是随着代码的执行在不同的状态之间进行切换。转换图如下:

新建状态

  • 使用new关键字创建线程之后,线程就处于新建状态,此时JVM为其分配了内存,并初始化了成员变量。此时并没有表现出线程的任何动态特征,程序也不会执行线程执行体。

就绪状态

  • 对象调用了start()方法后,该线程就处于就绪状态,JVM会为其创建方法调用栈和程序计数器,处于这个状态的线程并没有运行,只是表示可以运行了,何时运行,取决于系统调度。

运行状态

  • 就绪状态的线程,获得CPU之后,就处于运行状态,当当前的时间片用完,或者运行yield()/sleep()方法时,线程就必须放弃CPU,结束运行状态。

阻塞状态/等待/超时等待

  • 线程调用sleep()/join()/wait()方法,放弃CPU资源,线程被阻塞/等待
  • 线程调用了一个IO方法,在该方法返回前,被阻塞
  • 线程试图获取一个同步监视器,但是失败了,被阻塞
  • 线程在等待某个通知

线程结束

  • run()/call()方法执行体执行完成,线程正常结束
  • 抛出Exception/Error
  • 调用线程结束控制

上面提到了线程创建的三种方式,在代码层级来看看线程的具体实现:

线程的创建

继承Thread类

public class ThreadTest extends  Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("我是线程执行体 !");
    }
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

实现Runnable接口

class RunnableTest implements Runnable{
    @Override
    public void run() {
        System.out.println("runnable 执行体");
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableTest());
        thread.start();
    }
}

实现Callable接口和FutureTask

class callableTest implements Callable{

    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return 3;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        callableTest callableTest = new callableTest();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableTest);
        Thread thread = new Thread(futureTask , "有返回值的线程");
        thread.start();
        System.out.println(Thread.currentThread().getName());
        System.out.println(futureTask.get());
    }
}

上面展示了三种创建线程的三种方式,下面做一下简要的分析:

  • 实现接口的方式,还可以继承其他的类
  • 多个线程可以共享同一个target对象,适合多个线程来处理同一份资源。但是编程稍微复杂
  • 继承Thread类的方式不能在继承其它的类,但是编写简单。

一般推荐使用实现接口的方式来创建多线程。

线程执行的任务定义在了run()方法中,只有通过start()方法才能创建线程,这是为什么呢,通过源代码来分析一下:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Runable是一个函数式接口,定义也比较简单,只是定义了一个抽象的方法。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

Callable也是一个函数式接口,并且支持泛型,并返回泛型的类型。

看一下Thread类的实现,Thread类的代码比较多,这里只阐述一些重要的点:

先来看Thread类的定义

public class Thread implements Runnable

Thead类实现了Runable接口

构造方法: Thread类提供了9个构造方法,只阐述2个构造方法,这两个也是最常用的方法,

如下:

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

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

    //init 方法重载
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {

        this.name = name.toCharArray();
        //删除了一些代码,这些代码会获取一些父线程的属性,并设置到当前线程
        ....  

        this.target = target;  //敲黑板,画重点
    }

上面的代码是一个线程的创建过程,包括获取一些父进程的属性,如设置线程的名字,设置是否是守护进程,优先级等。

如果在创建线程的时候没有指定线程的名字,那么线程的名字为:Thread-num的形式,就是通过上面的代码来创建的,nextThreadNum()方法会返回一个数字,nextThreadNum()是一个被synchronized关键字修饰的方法,会将一个被static int类型修饰的整数进行+1操作,并返回,这样就保证了线程的名字不会重复,当然也可以自己指定线程的名字,在创建的时候传入即可。

上面代码target是一个私有的Runable变量,定义如下:

 private Runnable target;

看一下Thread类的start()方法:

    public synchronized void start() {

        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();   //敲黑板,画重点,调用start0()方法
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

start()方法是一个同步方法,并且会调用start0()来运行,start0()方法是一个被native修饰的本地方法,将委托给操作系统来运行,并调用run()方法。

定义如下:

private native void start0();

调用start()方法后,线程就处于了就绪状态,系统调度后,变为运行状态,并调用run()方法, 看一下run()方法的定义:

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

Thread类实现了Runbale接口所以必须要实现run(),run()方法的实现比较简单,首先判断target对象是否为null,如果为null就什么也不做,如果不为null,则调用target对象的run()方法。

分析到这,应该就能明白,有很多书上都说,无论是继承Thread类,还是实现了Runable接口都必须要重写run()方法,原因就在这。

总结

  • 继承Thread类的对象,调用Thread类的无参构造方法,此时target对象为空,但是它重写了run()方法,它会调用自己的run方法,实现了Runnable接口的对象,需要借助Thread(Runable target ) 构造方法运行 , 此时target对象不为空,会调用target的run()方法。
  • 关于Callable和FutureTask的实现方式,这里简单说一下, FutureTask实现了 RunnableFuture接口, 而RunnableFuture接口继承了Runable接口, 所以它能通过new Thread(Runnable target)构造函数来运行。会调用FutureTask的run()方法,在run()方法中调用了Callable对象的call()方法,获得了其返回值,换句话说 FutureTask对象封装了该Callable对象的返回值。通过FutureTask的get()方法来获得子线程执行结束后的返回值。

线程控制

  • join线程:让一个线程等待另一个线程执行完成的方法 join() ,主线程创建了一个子线程,并且调用了join()方法,那么主线程只有等待子线程执行完成后,才能向下运行。如果调用了join(long millis)主线程会在等到millis时间后向下执行。
  • 守护线程(daemon):一个线程设置成为守护线程后,会随着前台线程的结束而结束。GC(垃圾回收)就是一个非常典型的守护进程。
  • 线程睡眠sleep():使线程进入阻塞状态,不在运行
  • 线程让步yield():yield和sleep有点类似,不同是它进入的不是阻塞状态,而是就绪状态。

 

© 著作权归作者所有

郑加威
粉丝 175
博文 183
码字总数 387300
作品 0
杭州
架构师
私信 提问
Java 并发编程源码解析汇总篇

java并发编程,内存模型 java并发编程,volatile内存实现和原理 Java并发编程,并发基础 Java 并发编程,线程池(ThreadPoolExecutor)源码解析 Java并发编程,Executor 框架介绍 Java并发编...

郑加威
2018/12/23
0
0
读书笔记之《Java并发编程的艺术》-并发编程容器和框架(重要)

读书笔记部分内容来源书出版书,版权归本书作者,如有错误,请指正。 欢迎star、fork,读书笔记系列会同步更新 git https://github.com/xuminwlt/j360-jdk module j360-jdk-thread/me.j360....

Hi徐敏
2015/11/11
723
1
读书笔记之《Java并发编程的艺术》-并发编程基础

读书笔记部分内容来源书出版书,版权归本书作者,如有错误,请指正。 欢迎star、fork,读书笔记系列会同步更新 git https://github.com/xuminwlt/j360-jdk module j360-jdk-thread/me.j360....

Hi徐敏
2015/11/11
4K
8
「原创」Java并发编程系列01 开篇获奖感言

  全网都是复制粘贴的文章,师长这里一直坚持输出原创   点击上方“java进阶架构师”,选择右上角“置顶公众号   不要错过每一天的原创!      为什么要学并发编程   我曾听一个...

java进阶架构师
09/28
0
0
Java 10大优点—Part4—Java内存模型

在忙着参加在爱沙尼亚进行的 TEDx talk 演讲活动以及在比利时举办的一届非常忙碌的Devoxx 会议的间隙,我将继续推进 Java’s Rocking 的系列博文。 对还没有接触过这个系列博文的读者,不妨先...

foxlee
2013/12/09
425
1

没有更多内容

加载失败,请刷新页面

加载更多

TiDB 最佳实践系列(三)乐观锁事务

作者:Shirly TiDB 最佳实践系列是面向广大 TiDB 用户的系列教程,旨在深入浅出介绍 TiDB 的架构与原理,帮助用户在生产环境中最大限度发挥 TiDB 的优势。我们将分享一系列典型场景下的最佳实...

TiDB
43分钟前
9
0
原来缓存是这样

经过一闪而过的一个灵感,记下来,我觉得缓存的定义应该是这样定义的: 我之前一直认为缓存的词义是错误的:是在读取到值之后,再次被使用的时候,不会去取新的值,而是使用旧的值,这是是错...

走向人生巅峰的大路
45分钟前
6
0
数字货币交易所开发常用的7个开源撮合引擎

如果你希望按照自己的需求打造金融交易平台,那么应当选择合适的交易撮合引擎进行二次开发而不是基于完整的交易平台实现进行修改。本文将介绍10个采用不同语言开发的开源的撮合引擎,你可以根...

汇智网教程
48分钟前
7
0
Spring Security做JWT认证和授权

Spring Security做JWT认证和授权

乐逍遥-镜子
49分钟前
5
0
LNMP---日志不记录静态文件、日志切割、静态文件过期缓存、nginx防盗链

4.39 日志不记录静态文件 4.40 日志切割 4.41 静态文件过期缓存 4.42 nginx防盗链 扩展: yum install lrzsz -yrz 上传文件sz filename 这样去把这个文件推送到windows上 一、日志不记录...

tobej
今天
8
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部