Java多线程学习(一)Java多线程入门

Java面试通关手册(Java学习指南,欢迎Star,会一直完善下去,欢迎建议和指导):https://github.com/Snailclimb/Java_Guide

转载请备注地址:https://blog.csdn.net/qq_34337272/article/details/79640870

系列文章传送门:

Java并发编程专栏

Java多线程学习(一)Java多线程入门

Java多线程学习(二)synchronized关键字(1)

Java多线程学习(二)synchronized关键字(2)

Java多线程学习(三)volatile关键字

Java多线程学习(四)等待/通知(wait/notify)机制

最近听很多面试的小伙伴说,网上往往是一篇一篇的Java多线程的文章,除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习,而且面试的时候多线程这方面的知识往往也是考察的重点,所以考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识作以系统的讲述。

本节思维导图:

<font color="red">思维导图源文件+思维导图软件关注微信公众号:“Java面试通关手册”</font>回复关键字:“Java多线程”免费领取。

一 进程和多线程简介

1.1 相关概念

何为线程?

线程与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的<font color="red">多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间作切换工作时,负担要比进程小得多</font>,也正因为如此,<font color="red">线程也被称为轻量级进程</font>。

何为进程?

<font color="red">进程是程序的一次执行过程</font>,是系统运行程序的基本单位,因此进程是动态的。<font color="red">系统运行一个程序即是一个进程从创建,运行到消亡的过程</font>。简单来说,<font color="red">一个进程就是一个执行中的程序</font>,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。

线程和进程有何不同?

线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上<font color="red">各进程是独立的,而各线程则不一定</font>,因为同一进程中的线程极有可能会相互影响。从另一角度来说,进程属于操作系统的范畴,主要是同一段时间内,可以同时执行一个以上的程序,而线程则是在同一程序内几乎同时执行一个以上的程序段。

1.2 多线程

何为多线程?

多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行,也就是交替运行。多核CPU的话,因为每个CPU有自己的运算器,所以在多个CPU中可以同时运行。

为什么多线程是必要的?

  1. 使用线程可以把占据长时间的程序中的任务放到后台去处理
  2. 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度
  3. 程序的运行速度可能加快

二 使用多线程

2.1继承Thread类

<font size="2">MyThread.java</font>

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

<font size="2">Run.java</font>

public class Run {

	public static void main(String[] args) {
		MyThread mythread = new MyThread();
		mythread.start();
		System.out.println("运行结束");
	}

}

<font size="2">运行结果:</font>

结果

从上面的运行结果可以看出:<font color="red">线程是一个子任务,CPU以不确定的方式,或者说是以随机的时间来调用线程中的run方法</font>。

2.2实现Runnable接口

<font color="red">推荐实现Runnable接口方式开发多线程,因为Java单继承但是可以实现多个接口</font>。

<font size="2">MyRunnable.java</font>

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("MyRunnable");
	}
}

<font size="2">Run.java</font>

public class Run {

	public static void main(String[] args) {
		Runnable runnable=new MyRunnable();
		Thread thread=new Thread(runnable);
		thread.start();
		System.out.println("运行结束!");
	}

}

<font size="2">运行结果:</font>

运行结果

三 实例变量和线程安全

定义线程类中的实例变量针对其他线程可以有共享和不共享之分

3.1 不共享数据的情况

<font size="2">MyThread.java</font>

public class MyThread extends Thread {

	private int count = 5;

	public MyThread(String name) {
		super();
		this.setName(name);
	}

	@Override
	public void run() {
		super.run();
		while (count > 0) {
			count--;
			System.out.println("由 " + MyThread.currentThread().getName()
					+ " 计算,count=" + count);
		}
	}
}

<font size="2">Run.java</font>

public class Run {
	public static void main(String[] args) {
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		a.start();
		b.start();
		c.start();
	}
}

<font size="2">运行结果:</font>

运行结果

可以看出每个线程都有一个属于自己的实例变量count,它们之间互不影响。我们再来看看另一种情况。

3.2 共享数据的情况

<font size="2">MyThread.java</font>

public class MyThread extends Thread {

	private int count = 5;

	@Override
	 public void run() {
		super.run();
		count--;
		System.out.println("由 " + MyThread.currentThread().getName() + " 计算,count=" + count);
	}
}

<font size="2">Run.java</font>

public class Run {
	public static void main(String[] args) {
		
		MyThread mythread=new MyThread();
        //下列线程都是通过mythread对象创建的
		Thread a=new Thread(mythread,"A");
		Thread b=new Thread(mythread,"B");
		Thread c=new Thread(mythread,"C");
		Thread d=new Thread(mythread,"D");
		Thread e=new Thread(mythread,"E");
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}

<font size="2">运行结果:</font>

运行结果

可以看出这里已经出现了错误,我们想要的是依次递减的结果。<font color="red">为什么呢??</font>

因为在大多数jvm中,count--的操作分为如下下三步:

  1. 取得原有count值
  2. 计算i -1
  3. 对i进行赋值

所以多个线程同时访问时出现问题就是难以避免的了。

<font color="red">那么有没有什么解决办法呢?</font>

答案是:当然有,而且很简单。

<font color="red">在run方法前加上synchronized关键字即可得到正确答案</font>。

<font size="2">加上关键字后的运行结果:</font>

加上关键字后的运行结果

四 一些常用方法

4.1 currentThread()

返回对当前正在执行的线程对象的引用。

4.2 getId()

返回此线程的标识符

4.3 getName()

返回此线程的名称

4.4 getPriority()

返回此线程的优先级

4.5 isAlive()

测试这个线程是否还处于活动状态。

<font color="red">什么是活动状态呢?</font>

<font color="red">活动状态</font>就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

4.6 sleep(long millis)

使当前正在执行的线程以指定的毫秒数“休眠”(暂时停止执行),具体取决于系统定时器和调度程序的精度和准确性。

4.7 interrupt()

中断这个线程。

4.8 interrupted() 和isInterrupted()

interrupted():测试当前线程是否已经是中断状态,执行后具有将状态标志清除为false的功能

isInterrupted(): 测试线程Thread对相关是否已经是中断状态,但部清楚状态标志

4.9 setName(String name)

将此线程的名称更改为等于参数 name 。

4.10 isDaemon()

测试这个线程是否是守护线程。

4.11 setDaemon(boolean on)

将此线程标记为 daemon线程或用户线程。

<font color="red">4.12 join()</font>

在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是<font color="red">主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()方法了</font>。

join()的作用是:<font color="red">“等待该线程终止”</font>,这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码,只有等到子线程结束了才能执行

<font color="red">4.13 yield()</font>

yield()方法的作用是放弃当前的CPU资源,将它让给其他的任务去占用CPU时间。注意:放弃的时间不确定,可能一会就会重新获得CPU时间片。

4.14 setPriority(int newPriority)

更改此线程的优先级

五 如何停止一个线程呢?

stop(),suspend(),resume()(仅用于与suspend()一起使用)这些方法已被弃用,所以我这里不予讲解。

5.1 使用interrupt()方法

我们上面提到了interrupt()方法,先来试一下interrupt()方法能不能停止线程

<font size="2">MyThread.java</font>

public class MyThread extends Thread {
	@Override
	public void run() {
		super.run();
		for (int i = 0; i < 5000000; i++) {
			System.out.println("i=" + (i + 1));
		}
	}
}

<font size="2">Run.java</font>

public class Run {

	public static void main(String[] args) {
		try {
			MyThread thread = new MyThread();
			thread.start();
			Thread.sleep(2000);
			thread.interrupt();
		} catch (InterruptedException e) {
			System.out.println("main catch");
			e.printStackTrace();
		}
	}

}

运行上诉代码你会发现,<font color="red">线程并不会终止</font>。

针对上面代码的一个<font color="red">改进:</font>

interrupted()方法判断线程是否停止,如果是停止状态则break

<font size="2">MyThread.java</font>

public class MyThread extends Thread {
	@Override
	public void run() {
		super.run();
		for (int i = 0; i < 500000; i++) {
			if (this.interrupted()) {
				System.out.println("已经是停止状态了!我要退出了!");
				break;
			}
			System.out.println("i=" + (i + 1));
		}
		System.out.println("看到这句话说明线程并未终止------");
	}
}

<font size="2">Run.java</font>

public class Run {

	public static void main(String[] args) {
		try {
			MyThread thread = new MyThread();
			thread.start();
			Thread.sleep(2000);
			thread.interrupt();
		} catch (InterruptedException e) {
			System.out.println("main catch");
			e.printStackTrace();
		}
		System.out.println("end!");
	}

}

<font size="2">运行结果:</font>

运行结果

for循环虽然停止执行了,但是for循环下面的语句还是会执行,说明线程并未被停止。

5.2 使用return停止线程

<font size="2"> MyThread.java</font>

public class MyThread extends Thread {

	@Override
	public void run() {
			while (true) {
				if (this.isInterrupted()) {
					System.out.println("ֹͣ停止了!");
					return;
				}
				System.out.println("timer=" + System.currentTimeMillis());
			}
	}

}

<font size="2"> Run.java</font>

public class Run {

	public static void main(String[] args) throws InterruptedException {
		MyThread t=new MyThread();
		t.start();
		Thread.sleep(2000);
		t.interrupt();
	}

}

<font size="2"> 运行结果:</font>

运行结果

当然还有其他停止线程的方法,后面再做介绍。

六 线程的优先级

每个线程都具有各自的优先级,<font color="red">线程的优先级可以在程序中表明该线程的重要性,如果有很多线程处于就绪状态,系统会根据优先级来决定首先使哪个线程进入运行状态</font>。但这个并不意味着低

优先级的线程得不到运行,而只是它运行的几率比较小,如垃圾回收机制线程的优先级就比较低。所以很多垃圾得不到及时的回收处理。

<font color="red">线程优先级具有继承特性</font>比如A线程启动B线程,则B线程的优先级和A是一样的。

<font color="red">线程优先级具有随机性</font>也就是说线程优先级高的不一定每一次都先执行完。

Thread类中包含的成员变量代表了线程的某些优先级。如Thread.MIN_PRIORITY(常数1)Thread.NORM_PRIORITY(常数5),

Thread.MAX_PRIORITY(常数10)。其中每个线程的优先级都在Thread.MIN_PRIORITY(常数1)Thread.MAX_PRIORITY(常数10) 之间,在默认情况下优先级都是Thread.NORM_PRIORITY(常数5)

学过操作系统这门课程的话,我们可以发现多线程优先级或多或少借鉴了操作系统对进程的管理。

线程优先级具有继承特性测试代码:

<font size="2"> MyThread1.java:</font>

public class MyThread1 extends Thread {
	@Override
	public void run() {
		System.out.println("MyThread1 run priority=" + this.getPriority());
		MyThread2 thread2 = new MyThread2();
		thread2.start();
	}
}

<font size="2"> MyThread2.java:</font>

public class MyThread2 extends Thread {
	@Override
	public void run() {
		System.out.println("MyThread2 run priority=" + this.getPriority());
	}
}

<font size="2"> Run.java:</font>

public class Run {
	public static void main(String[] args) {
		System.out.println("main thread begin priority="
				+ Thread.currentThread().getPriority());
		Thread.currentThread().setPriority(6);
		System.out.println("main thread end   priority="
				+ Thread.currentThread().getPriority());
		MyThread1 thread1 = new MyThread1();
		thread1.start();
	}
}

<font size="2"> 运行结果:</font>

运行结果

七 Java多线程分类

7.1 多线程分类

<font color="red">用户线程</font>:运行在前台,执行具体的任务,如程序的主线程、连接网络的子线程等都是用户线程

<font color="red">守护线程</font>:运行在后台,为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 “佣人”

<font color="red">特点</font>:一旦所有用户线程都结束运行,守护线程会随JVM一起结束工作

<font color="red">应用</font>:数据库连接池中的检测线程,JVM虚拟机启动后的检测线程

<font color="red">最常见的守护线程</font>:垃圾回收线程

7.2 如何设置守护线程?</font>

可以通过调用<font color="red">Thead类的setDaemon(true)方法</font>设置当前的线程为守护线程

<font color="red">注意事项:</font>

1.  setDaemon(true)必须在start()方法前执行,否则会抛出IllegalThreadStateException异常
2. 在守护线程中产生的新线程也是守护线程
3. 不是所有的任务都可以分配给守护线程来执行,比如读写操作或者计算逻辑

<font size="2"> MyThread.java:</font>

public class MyThread extends Thread {
	private int i = 0;

	@Override
	public void run() {
		try {
			while (true) {
				i++;
				System.out.println("i=" + (i));
				Thread.sleep(100);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

<font size="2"> Run.java:</font>

public class Run {
	public static void main(String[] args) {
		try {
			MyThread thread = new MyThread();
			thread.setDaemon(true);
			thread.start();
			Thread.sleep(5000);
			System.out.println("我离开thread对象也不再打印了,也就是停止了!");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

<font size="2"> 运行结果:</font>

守护线程

如果你觉得博主的文章不错,欢迎转发点赞。你能从中学到知识就是我最大的幸运。

欢迎关注我的微信公众号:“Java面试通关手册”(分享各种Java学习资源,面试题,以及企业级Java实战项目回复关键字免费领取):

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

编辑于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Spark学习技巧

ConcurrentLinkedQueue和LinkedBlockingQueue用法

作者: Ruthless 关注 - 28 粉丝 - 2969 在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列(先进先出)。J...

3985
来自专栏aoho求索

基于redis的分布式锁实现

关于分布式锁 很久之前有讲过并发编程中的锁并发编程的锁机制:synchronized和lock。在单进程的系统中,当存在多个线程可以同时改变某个变量时,就需要...

3598
来自专栏芋道源码1024

数据结构 | Java 队列 —— Queue 详细分析

摘要: 原创出处 https://www.cnblogs.com/lemon-flm/p/7877898.html 「低调人生」欢迎转载,保留摘要,谢谢!

1270
来自专栏代码世界

Python之线程

操作系统线程理论 线程概念的引入背景 进程 之前我们已经了解了操作系统中进程的概念,程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种...

3988
来自专栏会跳舞的机器人

java并发编程的艺术笔记第一章——并发编程的挑战

单核处理器也支持多线程执行代码,CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间,因为时间片非常短,所以CPU通过不停地切...

843
来自专栏栗霖积跬步之旅

java多线程编程核心技术——第一章总结 1.5sleep()方法

1.1进程、多线程的概念及线程的优点 进程的概念: 百度百科讲解: 进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和...

16910
来自专栏老马说编程

(67) 线程的基本协作机制 (上) / 计算机程序的思维逻辑

上节介绍了多线程之间竞争访问同一个资源的问题及解决方案synchronized,我们提到,多线程之间除了竞争,还经常需要相互协作,本节就来介绍Java中多线程协...

1996
来自专栏加米谷大数据

MapReduce作业调度

可以通过设置mapred.job.priority属性或JobClient的setJobPriority()方法来设置优先级(在这两种方法中,可以选VERY_H...

35712
来自专栏Java后端技术

深入聊聊Java多线程

  在没有学习Java多线程以前,总觉得多线程是个很神秘的东西,只有那些大神才能驾驭,新年假期没事就来学习和了解一下Java的多线程,本篇博客我们就来从头说一下...

894
来自专栏北京马哥教育

python线程笔记

豌豆贴心提醒,本文阅读时间5分钟 来源:伯乐在线 原文:http://python.jobbole.com/87498/ 引言&动机 考虑一下...

1865

扫码关注云+社区