Java多线程深入理解
在java中要想实现多线程,有两种手段,一种是继续Thread类,另外一种是实现Runable接口。
对于直接继承Thread的类来说,代码大致框架是:
1
2
3
4
5
6
7
8
9
10
11
|
class 类名 extends Thread{ 方法 1 ; 方法 2 ; … public void run(){ // other code… } 属性 1 ; 属性 2 ; … } |
先看一个简单的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
/** * @author Hashsound 继承Thread类,直接调用run方法 * */ class hello extends Thread { private String name; public hello() { } public hello(String name) { this .name = name; } public void run() { for ( int i = 0 ; i < 5 ; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1 = new hello( "A" ); hello h2 = new hello( "B" ); h1.run(); h2.run(); } } |
【运行结果】:
A运行 0 A运行 1 A运行 2 A运行 3 A运行 4 B运行 0 B运行 1 B运行 2 B运行 3 B运行 4
我们会发现这些都是顺序执行的,说明我们的调用方法不对,应该调用的是start()方法。
当我们把上面的主函数修改为如下所示的时候:
1
2
3
4
5
6
|
public static void main(String[] args) { hello h1= new hello( "A" ); hello h2= new hello( "B" ); h1.start(); h2.start(); } |
然后运行程序,输出的可能的结果如下:
B运行 0 B运行 1 B运行 2 A运行 0 A运行 1 A运行 2 B运行 3 B运行 4 A运行 3 A运行 4
因为需要用到CPU的资源,所以每次的运行结果基本是都不一样的,呵呵。
注意:虽然我们在这里调用的是start()方法,但是实际上调用的还是run()方法的主体。
那么:为什么我们不能直接调用run()方法呢?
我的理解是:线程的运行需要本地操作系统的支持。
如果你查看start的源代码的时候,会发现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state "NEW". */ if (threadStatus != 0 || this != me) throw new IllegalThreadStateException(); group.add( this ); start0(); if (stopBeforeStart) { stop0(throwableFromStop); } } private native void start0(); |
注意我用红色加粗的那一条语句,说明此处调用的是start0()。并且这个这个方法用了native关键字,次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。
但是start方法重复调用的话,会出现java.lang.IllegalThreadStateException异常。
通过实现Runnable接口:
大致框架是:
来先看一个小例子吧:
1
2
3
4
5
6
7
8
9
10
11
|
class 类名 implements Runnable{ 方法 1 ; 方法 2 ; … public void run(){ // other code… } 属性 1 ; 属性 2 ; … } |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
/** * @author Hashsound 实现Runnable接口 * */ class hello implements Runnable { public hello() { } public hello(String name) { this .name = name; } public void run() { for ( int i = 0 ; i < 5 ; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1= new hello( "线程A" ); Thread demo= new Thread(h1); hello h2= new hello( "线程B" ); Thread demo1= new Thread(h2); demo.start(); demo1.start(); } private String name; } |
【可能的运行结果】:
线程A运行 0 线程B运行 0 线程B运行 1 线程B运行 2 线程B运行 3 线程B运行 4 线程A运行 1 线程A运行 2 线程A运行 3 线程A运行 4
关于选择继承Thread还是实现Runnable接口?
其实Thread也是实现Runnable接口的:
1
2
3
4
5
6
7
8
|
class Thread implements Runnable { //… public void run() { if (target != null ) { target.run(); } } } |
其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有,Thread和Runnable都实现了run方法,这种操作模式其实就是代理模式。
Thread和Runnable的区别:
如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/** * @author Rollen-Holt 继承Thread类,不能资源共享 * */ class hello extends Thread { public void run() { for ( int i = 0 ; i < 7 ; i++) { if (count > 0 ) { System.out.println( "count= " + count--); } } } public static void main(String[] args) { hello h1 = new hello(); hello h2 = new hello(); hello h3 = new hello(); h1.start(); h2.start(); h3.start(); } private int count = 5 ; } |
【运行结果】:
count= 5 count= 4 count= 3 count= 2 count= 1 count= 5 count= 4 count= 3 count= 2 count= 1 count= 5 count= 4 count= 3 count= 2 count= 1
大家可以想象,如果这个是一个买票系统的话,如果count表示的是车票的数量的话,说明并没有实现资源的共享。
我们换为Runnable接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class MyThread implements Runnable{ private int ticket = 5 ; //5张票 public void run() { for ( int i= 0 ; i<= 20 ; i++) { if ( this .ticket > 0 ) { System.out.println(Thread.currentThread().getName()+ "正在卖票" + this .ticket--); } } } } public class lzwCode { public static void main(String [] args) { MyThread my = new MyThread(); new Thread(my, "1号窗口" ).start(); new Thread(my, "2号窗口" ).start(); new Thread(my, "3号窗口" ).start(); } } |
【运行结果】:
count= 5 count= 4 count= 3 count= 2 count= 1
总结一下吧:
实现Runnable接口比继承Thread类所具有的优势:
1):适合多个相同的程序代码的线程去处理同一个资源
2):可以避免java中的单继承的限制
3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立。
所以,本人建议大家尽量实现接口。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * @author Hashsound * 取得线程的名称 * */ class hello implements Runnable { public void run() { for ( int i = 0 ; i < 3 ; i++) { System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) { hello he = new hello(); new Thread(he, "A" ).start(); new Thread(he, "B" ).start(); new Thread(he).start(); } } |
【运行结果】:
A A A B B B Thread-0 Thread-0 Thread-0
说明如果我们没有指定名字的话,系统自动提供名字。
提醒一下大家:main方法其实也是一个线程。在java中所以的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU的资源。
在java中,每次程序运行至少启动2个线程。一个是main线程,一个是垃圾收集线程。因为每当使用java命令执行一个类的时候,实际上都会启动一个JVM,每一个jVM实习在就是在操作系统中启动了一个进程。
判断线程是否启动
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * @author Hashsound 判断线程是否启动 * */ class hello implements Runnable { public void run() { for ( int i = 0 ; i < 3 ; i++) { System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he); System.out.println( "线程启动之前---》" + demo.isAlive()); demo.start(); System.out.println( "线程启动之后---》" + demo.isAlive()); } } |
【运行结果】
线程启动之前---》false 线程启动之后---》true Thread-0 Thread-0 Thread-0
主线程也有可能在子线程结束之前结束。并且子线程不受影响,不会因为主线程的结束而结束。
线程的强制执行:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
/** * @author Hashsound 线程的强制执行 * */ class hello implements Runnable { public void run() { for ( int i = 0 ; i < 3 ; i++) { System.out.println(Thread.currentThread().getName()); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he, "线程" ); demo.start(); for ( int i= 0 ;i< 50 ;++i){ if (i> 10 ){ try { demo.join(); //强制执行demo } catch (Exception e) { e.printStackTrace(); } } System.out.println( "main 线程执行-->" +i); } } } |
【运行的结果】:
main 线程执行-->0 main 线程执行-->1 main 线程执行-->2 main 线程执行-->3 main 线程执行-->4 main 线程执行-->5 main 线程执行-->6 main 线程执行-->7 main 线程执行-->8 main 线程执行-->9 main 线程执行-->10 线程 线程 线程 main 线程执行-->11 main 线程执行-->12 main 线程执行-->13 ...
线程的休眠:
/** * @author Hashsound 线程的休眠 * */ class hello implements Runnable { public void run() { for (int i = 0; i < 3; i++) { try { Thread.sleep(2000); } catch (Exception e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + i); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he, "线程"); demo.start(); } }
【运行结果】:(结果每隔2s输出一个)
线程0 线程1 线程2
线程的中断:
/** * @author Hashsound 线程的中断 * */ class hello implements Runnable { public void run() { System.out.println("执行run方法"); try { Thread.sleep(10000); System.out.println("线程完成休眠"); } catch (Exception e) { System.out.println("休眠被打断"); return; //返回到程序的调用处 } System.out.println("线程正常终止"); } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he, "线程"); demo.start(); try{ Thread.sleep(2000); }catch (Exception e) { e.printStackTrace(); } demo.interrupt(); //2s后中断线程 } }
【运行结果】:
执行run方法
休眠被打断
在java程序中,只要前台有一个线程在运行,整个java程序进程不会小时,所以此时可以设置一个后台线程,这样即使java进程小时了,此后台线程依然能够继续运行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * @author Hashsound 后台线程 * */ class hello implements Runnable { public void run() { while ( true ) { System.out.println(Thread.currentThread().getName() + "在运行" ); } } public static void main(String[] args) { hello he = new hello(); Thread demo = new Thread(he, "线程" ); demo.setDaemon( true ); demo.start(); } } |
虽然有一个死循环,但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。
线程的优先级:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/** * @author Hashsound 线程的优先级 * */ class hello implements Runnable { public void run() { for ( int i= 0 ;i< 5 ;++i){ System.out.println(Thread.currentThread().getName()+ "运行" +i); } } public static void main(String[] args) { Thread h1= new Thread( new hello(), "A" ); Thread h2= new Thread( new hello(), "B" ); Thread h3= new Thread( new hello(), "C" ); h1.setPriority( 8 ); h2.setPriority( 2 ); h3.setPriority( 6 ); h1.start(); h2.start(); h3.start(); } } |
【运行结果】:
A运行0 A运行1 A运行2 A运行3 A运行4 B运行0 C运行0 C运行1 C运行2 C运行3 C运行4 B运行1 B运行2 B运行3 B运行4
但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源、
另外,主线程的优先级是5.
线程的礼让。
在线程操作中,也可以使用yield()方法,将一个线程的操作暂时交给其他线程执行。
Java多线程深入理解的更多相关文章
- java多线程的理解
java多线程的理解 线程的5种状态:新建,就绪,运行,阻塞,死亡. Thread.sleep:线程 运行状态 转为 阻塞状态,(其它线程启动运行) Thread.yield: 线程 运行 ...
- (转载)Java多线程入门理解
转载出处http://blog.csdn.net/evankaka 写在前面的话:此文只能说是java多线程的一个入门,其实Java里头线程完全可以写一本书了,但是如果最基本的你都学掌握好,又怎么能更 ...
- synchronized与static synchronized 的差别、synchronized在JVM底层的实现原理及Java多线程锁理解
本Blog分为例如以下部分: 第一部分:synchronized与static synchronized 的差别 第二部分:JVM底层又是怎样实现synchronized的 第三部分:Java多线程锁 ...
- 温故知新-java多线程&深入理解线程池
文章目录 摘要 java中的线程 java中的线程池 线程池技术 线程池的实现原理 简述 ThreadPoolExecutor是如何运行的? 线程池运行的状态和线程数量 任务执行机制 队列缓存 Wor ...
- 谈谈你对Java多线程的理解以及多线程的实现方式
说线程之前先说进程,何为进程?进程就是正在进行中的程序.比如电脑同时在运行QQ进程.cmd进程.wps进程.飞秋进程等.在某一时刻,CPU只能执行一个程序,只是在做快速切换,我们肉眼看不出来. 比如: ...
- Java多线程的理解和实例
编写具有多线程程序经常会用到的方法:run(), start(), wait(), notify(), notifyAll(), sleep(), yield(), join() 还有一个关键字:sy ...
- Java多线程 -- 深入理解JMM(Java内存模型) --(五)锁
锁的释放-获取建立的happens before 关系 锁是Java并发编程中最重要的同步机制.锁除了让临界区互斥执行外,还可以让释放锁的线程向获取同一个锁的线程发送消息. 下面是锁释放-获取的示例代 ...
- 从JAVA多线程理解到集群分布式和网络设计的浅析
对于JAVA多线程的应用非常广泛,现在的系统没有多线程几乎什么也做不了,很多时候我们在何种场合如何应用多线程成为一种首先需要选择的问题,另外关于java多线程的知识也是非常的多,本文中先介绍和说明一些 ...
- 关于java多线程中异常捕获的理解
在java多线程程序中,所有线程都不允许抛出未捕获的checked exception(比如sleep时的InterruptedException),也就是说各个线程需要自己把自己的checked e ...
随机推荐
- linux命令详解——sar
Linux统计/监控工具SAR详细介绍:要判断一个系统瓶颈问题,有时需要几个 sar 命令选项结合起来使用,例如:怀疑CPU存在瓶颈,可用 sar -u 和 sar -q deng 等来查看 怀疑内存 ...
- D-Link系列路由器漏洞挖掘入门
D-Link系列路由器漏洞挖掘入门 前言 前几天去上海参加了geekpwn,看着大神们一个个破解成功各种硬件,我只能在下面喊 6666,特别羡慕那些大神们.所以回来就决定好好研究一下路由器,争取跟上大 ...
- struct:二进制数据结构的打包与解包
介绍 struct模块包括一些函数,这些函数可以完成字节串与原生Python数据类型(如数字和字符串)之间的转换 函数与Struct类 struct提供了一组处理结构值的模块级函数,另外还有一个Str ...
- The basic concept of information theory.
Deep Learning中会接触到的关于Info Theory的一些基本概念.
- 第七章 路由 75 路由传参-使用query方式传递参数
<!DOCTYPE html> <html lang="en"> <head> <meta charset="utf-8&quo ...
- ASP.netMVC验证码
.复制下列代码,拷贝到控制器中. #region 生成验证码图片 // [OutputCache(Location = OutputCacheLocation.None, Duration = 0, ...
- 【杂题】cf1041fF. Ray in the tube
死于没有处理边界 题目描述 题目大意 在两面镜子上各选定一个整数位置的点 A 与 B,并从其中一个点向另一个射出一条光线,使得接收到光线的传感器数量尽可能的多.传感器不重叠. 题目分析 我们来初步考虑 ...
- Java一棵树
手里有一枚java种子,刚播下,希望长出一棵参天大树. 一.Java Java线程 二.网络 三.算法 四.中间件 五.性能指标&优化 六.设计模式
- WPF界面开发技巧大放送!DevExpress WPF格式化日期时间值
DevExpress广泛应用于ECM企业内容管理. 成本管控.进程监督.生产调度,在企业/政务信息化管理中占据一席重要之地.通过DevExpress WPF Controls,您能创建有着强大互动功能 ...
- vector引用参数
#include<iostream> #include<vector> using namespace std; //定义一个计算数字的函数,返回计算后的vector numb ...