首页 / JAVA / [Java] Java核心（1）线程Thread详解

[Java] Java核心（1）线程Thread详解

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了[Java] Java核心（1）线程Thread详解，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7905字，纯文字阅读大概需要12分钟。

内容图文

1 概述

　　在开始学习Thread之前，我们先来了解一下线程和进程之间的关系：

　　线程(Thread)是进程的一个实体，是CPU调度和分派的基本单位。线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。线程和进程的关系是：线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。

　　由上描述，可以得知线程作为cpu的基本调度单位，只有把多线程用好，才能充分利用cpu的多核资源。

　　本文基于JDK 8（也可以叫JDK 1.8）。

2 线程使用

2.1 启动线程

　　创建线程有四种方式：

　　　　● 实现Runnable接口
　　　　● 继承Thread类
　　　　● 使用JDK 8 的Lambda
　　　　● 使用Callable和Future

2.1.1 Runnable创建方式

public class MyThread implements Runnable {
　　@Override
　　public void run() {
　　　　System.out.println(Thread.currentThread().getName());
　　}
}

Thread thread = new Thread(new MyThread());
thread.start();

2.1.2 继承Thread创建方式

public class MyThread extends Thread{
　　@Override
　　public void run() {
　　　　System.out.println(Thread.currentThread().getName());
　　}
}

MyThread thread = new MyThread();
thread.start();

　　以上代码有更简单的写法，如下：

Thread thread = new Thread(){
　　@Override
　　public void run() {
　　　　System.out.println(Thread.currentThread().getName());
　　}
};
thread.start();

2.1.3 Lambda创建方式

new Thread(()-> System.out.println(Thread.currentThread().getName())).start();

2.1.4 使用Callable和Future

　　看源码可以知道Thread的父类是Runnable是JDK1.0提供的，而Callable和Runnable类似，是JDK1.5提供的，弥补了调用线程没有返回值的情况，可以看做是Runnable的一个补充，下面看看Callable的实现。

public class MyThread implements Callable<String> {

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

Callable<String> callable = new MyThread();
FutureTask<String> ft = new FutureTask<>(callable);
new Thread(ft,"threadName").start();
System.out.println(ft.get());

2.1.5 run()和start()的区别

　　真正启动线程的是start()方法而不是run()，run()和普通的成员方法一样，可以重复使用，但不能启动一个新线程。

2.2 Thread的常用方法

　　Thread类方法

方法说明
start() 启动线程
setName(String name) 设置线程名称
setPriority(int priority) 设置线程优先级，默认5，取值1-10
join(long millisec) 挂起线程xx毫秒，参数可以不传
interrupt() 终止线程
isAlive() 测试线程是否处于活动状态

　　Thread静态（static）方法

方法说明
yield() 暂停当前正在执行的线程对象，并执行其他线程。
sleep(long millisec)/sleep(long millis, int nanos) 挂起线程xx秒，参数不可省略
currentThread() 返回对当前正在执行的线程对象的引用
holdsLock(Object x) 当前线程是否拥有锁

2.3 sleep()和wait()的区别

　　sleep为线程的方法，而wait为Object的方法，他们的功能相似，最大本质的区别是：sleep不释放锁，wait释放锁。

　　用法上的不同：sleep(milliseconds)可以用时间指定来使他自动醒过来，如果时间不到你只能调用interreput()来终止线程；wait()可以用notify()/notifyAll()直接唤起。

重点： 测试wait和sleep释放锁的代码如下：

public class SynchronizedTest extends Thread {
　　int number = 10;
　　public synchronized void first(){
　　　　System.out.println("this is first!");
　　　　number = number+1;
　　}
　　public synchronized void secord() throws InterruptedException {
　　　　System.out.println("this is secord!!");
　　　　Thread.sleep(1000);
　　　　// this.wait(1000);
　　　　number = number*100;
　　}
　　@Override
　　public void run() {
　　　　first();
　　}
}

SynchronizedTest synchronizedTest = new SynchronizedTest();
synchronizedTest.start();
synchronizedTest.secord();
// 主线程稍等10毫秒
Thread.sleep(10);
System.out.println(synchronizedTest.number);

　　根据结果可以得知：

执行sleep(1000)运行的结果是：1001
执行wait(1000)运行的结果是：1100
总结： 使用 sleep(1000)不释放同步锁，执行的是10*100+1=1001，wait(1000)释放了锁，执行的顺序是(10+1)x100=1100，所以sleep不释放锁，wait释放锁。

3 线程状态

3.1 线程状态概览

　　线程状态：

　　　　● NEW 尚未启动
　　　　● RUNNABLE 正在执行中
　　　　● BLOCKED 阻塞的（被同步锁或者IO锁阻塞）
　　　　● WAITING 永久等待状态
　　　　● TIMED_WAITING 等待指定的时间重新被唤醒的状态
　　　　● TERMINATED 执行完成

　　线程的状态可以使用getState()查看，更多状态详情，查看Thread源码，如下图：

[Java] Java核心（1）线程Thread详解 - 文章图片

3.2 线程的状态代码实现

3.2.1 NEW 尚未启动状态

Thread thread = new Thread() {
　　@Override
　　public void run() {
　　　　System.out.println(Thread.currentThread().getName());
　　}
};
// 只声明不调用start()方法，得到的状态是NEW
System.out.println(thread.getState()); // NEW

3.2.2 RUNNABLE 运行状态

Thread thread = new Thread() {
　　@Override
　　public void run() {
　　　　System.out.println(Thread.currentThread().getName());
　　}
};
thread.start();
System.out.println(thread.getState()); // RUNNABLE

3.2.3 BLOCKED 阻塞状态

　　使用synchronized同步阻塞实现，代码如下：

public class MyCounter {
　　int counter;
　　public synchronized void increase() {
　　　　counter++;
　　　　try {
　　　　　　Thread.sleep(10*1000);
　　　　} catch (InterruptedException e) {
　　　　　　e.printStackTrace();
　　　　}
　　}
}

MyCounter myCounter = new MyCounter();
// 线程1调用同步线程，模拟阻塞
new Thread(()-> myCounter.increase()).start();
// 线程2继续调用同步阻塞方法
Thread thread = new Thread(()-> myCounter.increase());
thread.start();

// 让主线程等10毫秒
Thread.currentThread().sleep(10);
// 打印线程2，为阻塞状态：BLOCKED
System.out.println(thread.getState());

3.2.4 WAITING 永久等待状态

public class MyThread extends Thread{
　　@Override
　　public void run() {
　　　　synchronized (MyThread.class){
　　　　　　try {
　　　　　　　　MyThread.class.wait();
　　　　　　　　System.out.println(Thread.currentThread().getName());
　　　　　　} catch (InterruptedException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　}
　　}
}

Thread thread = new Thread(new MyThread());
thread.start();
// 主线程挂起200毫秒，等thread执行完成
Thread.sleep(200);
// 输出WAITING，线程thread一直处于被挂起状态
System.out.println(thread.getState());

　　唤醒线程：可使用 notify/notifyAll 方法，代码如下：

synchronized (MyThread.class) {
　　MyThread.class.notify();
}

　　使线程WAITING的方法：

　　　　● Object的wait() 不设置超时时间
　　　　● Thread.join()不设置超时时间
　　　　● LockSupport的park()

　　查看Thread源码可以知道Thread的join方法，底层使用的是Object的wait实现的，如下图：

[Java] Java核心（1）线程Thread详解 - 文章图片

注意： 查看Object的源码可知wait()，不传递参数，等同于wait(0)，设置的“0”不是立即执行，而是无限的等待，不执行，如下图：

[Java] Java核心（1）线程Thread详解 - 文章图片

3.2.5 TIMED_WAITING 超时等待状态

　　TIMED_WAITING状态，只需要给wait设置上时间即可，代码如下：

public class MyThread extends Thread{
　　@Override
　　public void run() {
　　　　synchronized (MyThread.class){
　　　　　　try {
　　　　　　　　MyThread.class.wait(1000);
　　　　　　　　System.out.println(Thread.currentThread().getName());
　　　　　　} catch (InterruptedException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　}
　　}
}

　　调用代码还是一样的，如下：

Thread thread = new Thread(new MyThread());
thread.start();
// 主线程挂起200毫秒，等thread执行完成
Thread.sleep(200);
// 输出TIMED_WAITING
System.out.println(thread.getState());
synchronized (MyThread.class) {
　　MyThread.class.notify();
}

3.2.6 TERMINATED 完成状态

Thread thread = new Thread(()-> System.out.println(Thread.currentThread().getName()));
thread.start();
// 让主线程等10毫秒
Thread.currentThread().sleep(10);
System.out.println(thread.getState());

4 死锁

　　根据前面的知识，我们知道使用sleep的时候是不释放锁的，所以利用这个特性我们可以很轻易的写出死锁的代码，具体的流程如图（图片来源于杨晓峰老师文章）：

[Java] Java核心（1）线程Thread详解 - 文章图片

　　代码如下：

static Object object1 = new Object();
static Object object2 = new Object();

public static void main(String[] args) {

　　Thread thread = new Thread(){
　　@Override
　　public void run() {
　　　　synchronized (object1){
　　　　　　try {
　　　　　　　　Thread.sleep(1000);
　　　　　　} catch (InterruptedException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　　　synchronized (object2){
　　　　　　　　System.out.println(Thread.currentThread().getName());
　　　　　　}
　　　　}
　　}
};

Thread thread2 = new Thread(){
　　@Override
　　public void run() {
　　　　synchronized (object2){
　　　　　　try {
　　　　　　　　Thread.sleep(1000);
　　　　　　} catch (InterruptedException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　　　synchronized (object1){
　　　　　　　　System.out.println(Thread.currentThread().getName());
　　　　　　}
　　　　}
　　}
};

thread.start();
thread2.start();

　　运行上面的代码，程序会处于无限等待之中。

5 总结

　　根据上面的内容，我们已经系统的学习Thread的使用了，然而学而不思则罔，最后留一个思考题：根据本文介绍的知识，怎么能避免死锁？

　　源码下载：https://github.com/vipstone/java-core-example.git

参考文档

　　Java核心技术36讲：http://t.cn/EwUJvWA

　　https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.State.html

备注

　　原文链接：https://blog.csdn.net/sufu1065/article/details/84336444

内容总结

以上是互联网集市为您收集整理的[Java] Java核心（1）线程Thread详解全部内容，希望文章能够帮你解决[Java] Java核心（1）线程Thread详解所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/631722.html

来源：【匿名】

【上一篇】JavaArrayList和数组间的相互转换【下一篇】JAVA/JSP学习系列之五

更多 ►

【[Java] Java核心（1）线程Thread详解】教程文章相关的互联网学习教程文章

用Java实现生产者和消费者的多线程例子【代码】

任务说明：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。使用Runnable接口完成该任务，代码如下：package testThread;/*共享数据*/ class Clerk{int produc...

JAVA线程池之周期性地执行任务【代码】【图】

本文记录使用ScheduledExecutorService的 scheduleAtFixedRate 方法执行周期性任务的过程。一，正常任务执行负责执行任务的线程类如下：（一个计算阶乘的任务，计算5以上的阶乘，就会抛出异常） 1publicclass FactorialCalc implements Runnable {2 3private Integer number;4 5public FactorialCalc(Integer number) {6this.number = number;7 }8 9publicvoid run() { 1011int result = 1; 1213if (number == 0) { 14 ...

Java 学习笔记之线程Yield【代码】【图】

线程Yield： yield()方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间，但放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片。publicclass YieldThread extends Thread{@Overridepublicvoid run() {long beginTime = System.currentTimeMillis();int count = 0;for (int i = 0; i< 50000000; i++){//Thread.yield();count = count + (i + 1);}long endTime = System.currentTimeMillis();System.out.pri...

JAVA中的多线程(三)【代码】

多线程的运行出现了安全问题原因：　　当多条语句在操作同一个线程数据的时候，一个线程对多条语句只执行了一部分，还没执行完　　另一个线程参与进来执行，导致共享数据的错误解决办法：　　对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其它线程不可以参与执行。 JAVA对于多线程安全问题，提供了专业的解决方式就是同步代码块synchronized(对象){　　需要被同步的代码} 1class Ticket implements Runnable...

面试官：小伙子，说一说Java多线程有哪些创建方式吧【代码】

第一种继承Thread类自定义类,继承Thread类,并重写run()方法.class MyThread1 extends Thread {@Overridepublic void run() {System.out.println("第一种方式Thread " + Thread.currentThread().getName());} } public class Test {public static void main(String[] args) throws Exception {//第一种方式MyThread1 thread1 = new MyThread1();thread1.start();MyThread1 thread1 = new MyThread1();thread1.start();MyThread1 th...

国内首部Java多线程设计模式原创作品《Java多线程编程实战指南（设计模式篇）》已出版

国内首部Java多线程设计模式原创作品《Java多线程编程实战指南（设计模式篇）》已由电子工业出版社出版。本书从理论到实战，用生活化的实例和通俗易懂的语言全面介绍Java多线程编程的"三十六计"——多线程设计模式。当当、亚马逊、京东、互动出版网、淘宝等各大书店有售。【样章】http://viscent.iteye.com/category/328291【前言】随着现代CPU的生产工艺从提升CPU主频频率转向多核化，即在一块芯片上集成多个CPU内核（Core），以往...

java线程常用做法【代码】

介绍：在程序中，我们是不能随便中断一个线程的，因为这是极其不安全的操作，我们无法知道这个线程正运行在什么状态，它可能持有某把锁，强行中断可能导致锁不能释放的问题；或者线程可能在操作数据库，强行中断导致数据不一致混乱的问题。正因此，JAVA里将Thread的stop方法设置为过时，以禁止大家使用。一个线程什么时候可以退出呢？当然只有线程自己才能知道。所以我们这里要说的Thread的interrrupt方法，本质不是用来中断一个线...

Java 多线程——Thread类和Runable接口【代码】

在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限，下面看例子：[java] view plaincopypackage org.thread.demo; class MyThread extends Thread{ private String name; public MyThread(String name) { super(); this.name = nam...

Java 线程池的原理与实现

这几天主要是狂看源程序，在弥补了一些以前知识空白的同时，也学会了不少新的知识（比如 NIO），或者称为新技术吧。线程池就是其中之一，一提到线程，我们会想到以前《操作系统》的生产者与消费者，信号量，同步控制等等。一提到池，我们会想到数据库连接池，但是线程池又如何呢？建议：在阅读本文前，先理一理同步的知识，特别是syncronized同步关键字的用法。关于我对同步的认识，要缘于大三年的一本书，书名好像是 Java 实战...

java中的线程【代码】

1.什么是线程说到线程就是说进程,因为线程不能独立进程而存在. 进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。在这里我们要知道,真正执行任务的或占用CPU运行的是线程,所以说线程是CPU分配的基本单位. 我们通常写的java main函数就是一个线程,也程为主线程. 1.1线程创建...

（黑马Java多线程与并发库高级应用）02 传统定时器技术回顾【代码】

代码1：package cn.itcast.heima2;import java.util.Calendar; import java.util.Timer; import java.util.TimerTask;publicclass TraditionalTimerTest {publicstaticvoid main(String[] args) {new Timer().schedule(new TimerTask() {@Overridepublicvoid run() {System.out.println("OUTER:boom!");}},10000,3000);while(true){System.out.println(Calendar.getInstance().get(Calendar.SECOND));try {Thread.sleep(1000);} ca...

Java多线程基础：进程和线程之由来

Java多线程基础：进程和线程之由来　　在前面，已经介绍了Java的基础知识，现在我们来讨论一点稍微难一点的问题：Java并发编程。当然，Java并发编程涉及到很多方面的内容，不是一朝一夕就能够融会贯通使用的，需要在实践中不断积累。由于并发肯定涉及到多线程，因此在进入并发编程主题之前，我们先来了解一下进程和线程的由来，这对后面对并发编程的理解将会有很大的帮助。　　下面是本文的目录大纲：　　一.操作系统中为什么会出现...

Java 线程池

线程池（用完的线程归还到线程池中省去创建删除线程操作）public class Xianchengchi {public static void main(String[] args) throws InterruptedException,ExecutionException {//线程池对象=线程池工厂创建两个线程的线程池ExecutorService es=Executors.newFixedThreadPool(2);//两个线程MyRunnable mr=new MyRunnable(); //任务对象//MyCallable c = new MyCallable();CallSum cs = new CallSum(100); //任务有参构造 //Thr...

Java学习(十)：Java线程池实例【代码】【图】

线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。　　Java常用的线程池有四种。Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）、Executors.newFixedThreadPool(int)（固定大小线程池）、Executors...

java多线程【代码】

public static void main(){Resource r = new Resource();Producer pro = new Producer(r);Consumer con = new Consumer(r);Thread t1 = new Thread(pro);Thread t2= new Thread(con);t1.start();t2.start();}class Resource{private String name;private int count = 1;private bolean flag = flag;public synchroized void set(String name){}public synchroized void out(){} }class Producer implements Runnable{private Re...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / [Java] Java核心（1）线程Thread详解

[Java] Java核心（1）线程Thread详解

内容导读

内容图文

1 概述

2 线程使用

2.1 启动线程

2.1.1 Runnable创建方式

2.1.2 继承Thread创建方式

2.1.3 Lambda创建方式

2.1.4 使用Callable和Future

2.1.5 run()和start()的区别

2.2 Thread的常用方法

2.3 sleep()和wait()的区别

3 线程状态

3.1 线程状态概览

3.2 线程的状态代码实现

3.2.1 NEW 尚未启动状态

3.2.2 RUNNABLE 运行状态

3.2.3 BLOCKED 阻塞状态

3.2.4 WAITING 永久等待状态

3.2.5 TIMED_WAITING 超时等待状态

3.2.6 TERMINATED 完成状态

4 死锁

5 总结

参考文档

备注

内容总结

内容备注

内容手机端

【[Java] Java核心（1）线程Thread详解】教程文章相关的互联网学习教程文章

JAVA - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程