java多线程

Java多线程

部分转载自知乎用户 Snailclimb · 南理汉子 · 很好

Table of contents

• 进程和多线程简介
• 使用多线程
• 实例变量和线程安全
• 一些常用方法
• 如何停止一个线程
• 线程的优先级
• Java多线程分类

简介

• 相关概念
• 多线程

概念

• 何为线程
• 何为进程
• 线程和进程有何不同

通俗说法
开个QQ，开了一个进程；开了迅雷，开了一个进程。在QQ的这个进程里，传输文字开一个线程、传输语音开了一个线程、弹出对话框又开了一个线程。所以运行某个软件，相当于开了一个进程。在这个软件运行的过程里（在这个进程里），多个工作支撑的完成QQ的运行，那么这“多个工作”分别有一个线程。所以一个进程管着多个线程。通俗的讲：“进程是爹妈，管着众多的线程儿子”...

线程

线程进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。

进程

是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独 立运行的一段程序。

线程和进程有何不同

关系:

1. 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程)
   
2. 资源分配给进程，同一进程的所有线程共享该进程的所有资源
   
3. 线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
   
4. 处理机分给线程，即真正在处理机上运行的是线程
   
5. 线程是指进程内的一个执行单元，也是进程内的可调度实体

区别:

1. 调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
   
2. 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
   
3. 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。

多线程

多线程

多线程就是几乎同时执行多个线程（一个处理器在某一个时间点上永远都只能是一个线程！即使这个处理器是多核的，除非有多个处理器才能实现多个线程同时运行。）。几乎同时是因为实际上多线程程序中的多个线程实际上是一个线程执行一会然后其他的线程再执行，并不是很多书籍所谓的同时执行。

为什么多线程是必要的

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

假设你的公司从上到下都不知道多线程有什么用，就你知道。你刚进公司。比如你的机器是intel i7 4核，你要跑一个运算4万次，每次都独立，不考虑IO负担。那么，单线程你只能用到一个核，耗时40分钟，你打开任务管理器，看到CPU利用率一直是25%。你修改程序，开4个线程，每个算1万次，你看到CPU利用率一直是100%，耗时10分钟。你告诉老板40分钟后完成任务，10分钟后你检查完毕起身去买了杯咖啡，回来开始刷知乎。30分钟过后刷过瘾了，你发信息告诉老板任务完成。老板说：Good job.

使用

继承Thread类

MyThread.java

public class MyThread extends Thread { @Override public void run() { super.run(); int i = 1000; while (--i > 0) { System.out.println("|||||||||||||||||"); } System.out.println("MyThread"); } }

Run.java

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

运行结果:

运行结束
|||||||||||||||||
...
...
|||||||||||||||||
MyThread

以共有两个线程,一个是main,一个是mythread,如果把他们两个比作赛跑选手,main选手要做的事情是,先开始跑,紧接着喊mythread一声,老哥,开始跑吧,然后再喊一声运行结束,他就完成了任务,而mythread需要执行完一个长循环才可以结束

实现Runnable接口

推荐实现Runnable接口方式开发多线程，因为Java单继承但是可以实现多个接口,也就是相比上一个方法,这个方法在实现了多线程的同时还多出了选择继承一个父类的权利

MyRunnable.java

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

Run.java

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

运行结果
运行结束！
MyRunnable

实例变量和线程安全

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

不共享数据的情况

MyThread.java

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); } } }

Run.java

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(); } }

运行结果
由 A 计算，count=4
由 B 计算，count=4
由 C 计算，count=4
由 B 计算，count=3
由 A 计算，count=3
由 A 计算，count=2
由 A 计算，count=1
由 A 计算，count=0
由 B 计算，count=2
由 C 计算，count=3
由 B 计算，count=1
由 C 计算，count=2
由 B 计算，count=0
由 C 计算，count=1
由 C 计算，count=0

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

共享数据的情况

MyThread.java

public class MyThread extends Thread { private int count = 5; @Override public void run() { super.run(); count--; System.out.println("由 " + MyThread.currentThread().getName() + " 计算，count=" + count); } }

Run.java

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(); } }

运行结果
由 A 计算，count=3
由 C 计算，count=2
由 B 计算，count=3
由 D 计算，count=1
由 E 计算，count=0
可以看出这里已经出现了错误，我们想要的是依次递减的结果。为什么呢？？

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

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

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

那么有没有什么解决办法呢？

答案是：当然有，而且很简单。

在run方法前加上synchronized关键字即可得到正确答案。

加上关键字后的运行结果：

由 A 计算，count=4
由 E 计算，count=3
由 D 计算，count=2
由 B 计算，count=1
由 C 计算，count=0

一些常用方法

currentThread()

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

getId()

返回此线程的标识符

getName()

返回此线程的名称

getPriority()

返回此线程的优先级

isAlive()

测试这个线程是否还处于活动状态。
什么是活动状态呢？
活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

sleep(long millis)

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

interrupt()

中断这个线程。

interrupted() 和isInterrupted()

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

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

setName(String name)

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

isDaemon()

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

setDaemon(boolean on)

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

join()

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

join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行

yield()

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

setPriority(int newPriority)

更改此线程的优先级

停止一个线程

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

使用interrupt()方法

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

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

Run.java

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(); } } }

运行上诉代码你会发现，线程并不会终止。

针对上面代码的一个改进：

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

MyThread.java

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("看到这句话说明线程并未终止------"); } }

Run.java

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!"); } }

运行结果：
i=437968
i=437968
i=437968
...
end!
已经是停止状态了!我要退出了!
看到这句话说明线程并未终止

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

使用return终止线程

MyThread.java

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

Run.java

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

运行结果输出停止了后就没有继续输出,线程的确被终止了

线程的优先级

每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这个并不意味着低
优先级的线程得不到运行，而只是它运行的几率比较小，如垃圾回收机制线程的优先级就比较低。所以很多垃圾得不到及时的回收处理。

线程优先级具有继承特性比如A线程启动B线程，则B线程的优先级和A是一样的。

线程优先级具有随机性也就是说线程优先级高的不一定每一次都先执行完。

Thread类中包含的成员变量代表了线程的某些优先级。如Thread.MINPRIORITY（常数1），Thread.NORMPRIORITY（常数5）,
Thread.MAXPRIORITY（常数10）。其中每个线程的优先级都在Thread.MINPRIORITY（常数1） 到Thread.MAXPRIORITY（常数10） 之间，在默认情况下优先级都是Thread.NORMPRIORITY（常数5）。

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

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

MyThread1.java

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

MyThread2.java

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

Run.java

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(); } }

运行结果:
main thread begin priority=5
main thread end priority=6
MyThread1 run priority=6
MyThread2 run priority=6

Java多线程分类

多线程分类

用户线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程

守护线程：运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 “佣人”。

特点：一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作

应用：数据库连接池中的检测线程，JVM虚拟机启动后的检测线程

最常见的守护线程：垃圾回收线程

如何设置守护线程？

可以通过调用Thead类的setDaemon(true)方法设置当前的线程为守护线程

注意事项：

1. setDaemon(true)必须在start（）方法前执行，否则会抛出IllegalThreadStateException异常

1. 在守护线程中产生的新线程也是守护线程
   
2. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑

MyThread.java

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(); } } }

Run.java

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(); } } }

最后打印了主线程的我离开thread对象也不再打印了，也就是停止了！后,子线程的死循环输出也终止了