java-concurrent
  • 前言
  • Java多线程基础
    • 线程简介
      • 什么是线程
      • 为什么要使用多线程/线程使用的好处
      • 线程的优先级
      • 线程的状态
      • Daemon线程
    • 启动和终止线程
      • 构造线程
      • 启动线程
      • 中断线程
      • 过期的suspend()、resume()和stop()
      • 安全地终止线程
    • 多线程实现方式
    • 多线程环境下,局部变量和全局变量都会共享吗?
    • Java线程间的协助和通信
      • Thread.join的使用
      • volatile、ThreadLocal、synchronized3个关键字区别
      • volatile关键字
      • ThreadLocal关键字
      • synchronized关键字
      • Java线程等待和通知的相关方法
    • 实战应用
      • 连接池
      • 线程池
      • 如何计算合适的线程数
  • Java线程池与框架
    • Executor 框架
    • 自定义线程池——ThreadPoolExecutor
    • 线程池工具类(单例模式)
    • 关闭线程池
    • 合理地配置线程池
    • 线程池的监控
    • RejectedExecutionException产生的原因
    • SpringBoot配置线程池工具类
    • FutureTask详解
    • CompletionService讲解
    • Future、FutureTask、CompletionService、CompletableFuture区别
  • Java内存模型
    • Java 内存模型的基础
      • 并发编程模型的两个关键问题
      • Java内存模型的抽象结构
      • 从源代码到指令序列的重排序
      • 并发编程模型的分类
    • 重排序
      • 数据依赖性
      • as-if-serial语义
      • 程序顺序规则
      • 重排序对多线程的影响
    • 顺序一致性
      • 数据竞争与顺序一致性
      • 顺序一致性内存模型
      • 同步程序的顺序一致性效果
      • 未同步程序的执行特性
    • volatile内存语义
      • volatile的特性
      • volatile写-读建立的happens-before关系
      • volatile写-读的内存语义
      • volatile内存语义的实现
      • JSR-133为什么要增强volatile的内存语义
    • 锁内存定义
      • 锁的释放-获取建立的happens-before关系
      • 锁的释放和获取的内存语义
      • 锁内存语义的实现
      • concurrent包的实现
    • final域内存语义
      • final域的重排序规则
      • 写final域的重排序规则
      • 读final域的重排序规则
      • final域为引用类型
      • 为什么final引用不能从构造函数内“溢出”
      • final语义在处理器中的实现
      • JSR-133为什么要增强final的语义
    • happens-before
    • 双重检查锁定与延迟初始化
      • 双重检查锁定的由来
      • 问题的根源
      • 基于volatile的解决方案
      • 基于类初始化的解决方案
    • Java内存模型综述
      • 处理器的内存模型
      • 各种内存模型之间的关系
      • JMM的内存可见性保证
      • JSR-133对旧内存模型的修补
  • HashMap实现原理
    • 讲解(一)
    • 讲解(二)
    • HashMap原理(面试篇)
    • HashMap原理(面试篇二)
  • ConcurrentHashMap的实现原理与使用
    • 为什么要使用ConcurrentHashMap
    • ConcurrentHashMap的结构
    • ConcurrentHashMap的初始化
    • 定位Segment
    • ConcurrentHashMap的操作
    • ConcurrentHashMap讲解(一)
  • Java中的阻塞队列
    • 什么是阻塞队列
    • Java里的阻塞队列
    • 阻塞队列的实现原理
  • Fork/Join框架
    • 什么是Fork/Join框架
    • 工作窃取算法
    • Fork/Join框架的设计
    • 使用Fork/Join框架
    • Fork/Join框架的异常处理
    • Fork/Join框架的实现原理
    • ForkJoinPool的commonPool相关参数配置
  • java.util.concurrent包讲解
    • 线程安全AtomicInteger的讲解
    • CompletableFuture讲解
      • CompletableFuture接口详解
      • CompletableFuture与parallelStream()性能差异
      • CompletableFuture接口详解2
  • Java线程安全
    • 性能与可伸缩性
    • 解决死锁
    • 死锁定义
    • 如何让多线程下的类安全
    • 类的线程安全性定义
    • 实战:实现一个线程安全的单例模式
  • Java常用并发开发工具和类的源码分析
    • CountDownLatch
    • CyclicBarrier
    • Semaphore
    • Exchange
    • ConcurrentHashMap
    • ConcurrentSkipListMap
    • HashMap
      • HashMap源码实现及分析
      • HashMap的一些面试题
    • List
  • Java中的锁
    • 基础知识
    • 番外篇
    • synchronized 是可重入锁吗?为什么?
    • 自旋锁
  • Java多线程的常见问题
    • 常见问题一
Powered by GitBook
On this page

Was this helpful?

  1. Java多线程基础

多线程实现方式

Java 中实现多线程有两种方法:继承 Thread 类、实现 Runnable 接口,在程序开发中只要是多线程,肯定永远以实现 Runnable 接口为主,因为实现 Runnable 接口相比继承 Thread 类有如下优势:

  • 可以避免由于 Java 的单继承特性而带来的局限;

  • 增强程序的健壮性,代码能够被多个线程共享,代码与数据是独立的;

  • 适合多个相同程序代码的线程区处理同一资源的情况。

下面以典型的买票程序(基本都是以这个为例子)为例,来说明二者的区别。

首先通过继承 Thread 类实现,代码如下:

package com.ise.api.thread;

class MyThread extends Thread {
    private int ticket = 5;

    public void run() {
        for (int i = 0; i < 10; i++) {
            if (ticket > 0) {
                System.out.println("ticket = " + ticket--);
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
    }
}

执行结果如下:

从结果中可以看出,每个线程单独卖了 5 张票,即独立地完成了买票的任务,但实际应用中,比如火车站售票,需要多个线程去共同完成任务,在本例中,即多个线程共同买 5 张票。

下面是通过实现 Runnable 接口实现的多线程程序,代码如下:

package com.ise.api.thread;

class MyThread implements Runnable {
    private int ticket = 5;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (ticket > 0) {
                System.out.println("ticket = " + ticket--);
            }
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        MyThread my = new MyThread();
        new Thread(my).start();
        new Thread(my).start();
        new Thread(my).start();
    }
}

执行结果如下:

从结果中可以看出,三个线程一共卖了 5 张票,即它们共同完成了买票的任务,实现了资源的共享,可以通过打印

线程名称查看具具体的线程。

针对以上代码补充三点:

  • 在第二种方法(Runnable)中,ticket 输出的顺序并不是 54321,这是因为线程执行的时机难以预测,ticket--并不是原子操作。

  • 在第一种方法中,我们 new 了 3 个 Thread 对象,即三个线程分别执行三个对象中的代码,因此便是三个线程去独立地完成卖票的任务;而在第二种方法中,我们同样也 new 了 3 个 Thread 对象,但只有一个 Runnable 对象,3 个 Thread 对象共享这个 Runnable 对象中的代码,因此,便会出现 3 个线程共同完成卖票任务的结果。如果我们 new 出 3 个 Runnable 对象,作为参数分别传入 3 个 Thread 对象中,那么 3 个线程便会独立执行各自 Runnable 对象中的代码,即 3 个线程各自卖 5 张票。

  • 在第二种方法中,由于 3 个 Thread 对象共同执行一个 Runnable 对象中的代码,因此可能会造成线程的不安全,比如可能 ticket 会输出 -1(如果我们 System.out....语句前加上线程休眠操作,该情况将很有可能出现),这种情况的出现是由于,一个线程在判断 ticket 为 1>0 后,还没有来得及减 1,另一个线程已经将 ticket 减 1,变为了 0,那么接下来之前的线程再将 ticket 减 1,便得到了 -1。这就需要加入同步操作(即互斥锁),确保同一时刻只有一个线程在执行每次 for 循环中的操作。而在第一种方法中,并不需要加入同步操作,因为每个线程执行自己 Thread 对象中的代码,不存在多个线程共同执行同一个方法的情况。

Previous安全地终止线程Next多线程环境下,局部变量和全局变量都会共享吗?

Last updated 5 years ago

Was this helpful?