Java
多线程
在讲述Java多线程之前,我们不妨先了解一下线程和进程的区别以及它们之间的联系:
进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1-n
个线程。(进程是资源分配的最小单位)
线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC
),线程切换开销小。(线程是cpu
调度的最小单位)
了解完了进程和线程的概念,那么多线程又是什么呢,和多进程又有什么区别?多进程是指操作系统能同时运行多个任务(程序),而多线程就是指在同一程序中有多个顺序流在执行。在Java
中实现多线程,有两种主要的方式,一种是继承Thread
类,另外一种是实现Runable
接口。
一、继承java.lang.Thread
类
继承Thread
类是比较常用的方式,如果只有一种或者不多的几种线程,可以直接使用这种方式,重写run
方法。
一种参考的示例如下:
public class Thread01 {
public static void main(String[] args) {
//创建Cat对象,可以当做线程使用
Cat cat = new Cat();
cat.start();//启动线程
}
}
//说明:
//1.当一个类继承了 Thread 类,该类就可以当做线程使用
//2.我们会重写run方法,写上自己的代码
//3. run Thread 类实现了 Runnable 接口的 run 方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread {
int times = 0;
@Override
public void run() { //重写run方法,写上自己的代码逻辑
//该线程每隔一秒,在控制台输出“喵喵,我是小猫咪!”
while (true) {
System.out.println("喵喵,我是小猫咪!" + (++times));
//让该线程休眠1s
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
输出如下(无限输出):
为了不让线程无限输出下去,我们可以考虑让线程执行一定的次数:
public class Thread01 {
public static void main(String[] args) {
//创建Cat对象,可以当做线程使用
Cat cat = new Cat();
cat.start();//启动线程
}
}
//说明:
//1.当一个类继承了 Thread 类,该类就可以当做线程使用
//2.我们会重写run方法,写上自己的代码
//3. run Thread 类实现了 Runnable 接口的 run 方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread {
int times = 0;
@Override
public void run() { //重写run方法,写上自己的代码逻辑
//该线程每隔一秒,在控制台输出“喵喵,我是小猫咪!”
while (true) {
System.out.println("喵喵,我是小猫咪!" + (++times));
//让该线程休眠1s
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times == 10){
break;//当times为10时,退出while循环,线程也随之结束。
}
}
}
}
此时输出效果如下:
当 main
线程启动一个子线程 Thread-0
,主线程不会阻塞,会继续执行,这时主线程和子线程是交替执行的
验证代码如下:
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建Cat对象,可以当做线程使用
Cat cat = new Cat();
cat.start();//启动线程
//说明:当 main 线程启动一个子线程 Thread-0,主线程不会阻塞,会继续执行
//这时 主线程和子线程是交替执行的
System.out.println("主线程会继续执行" + Thread.currentThread().getName()); //主线程名:main
for (int i = 0; i < 10; i++) {
System.out.println("主线程 i=" + i);
//让主线程休眠
Thread.sleep(1000);
}
}
}
//说明:
//1.当一个类继承了 Thread 类,该类就可以当做线程使用
//2.我们会重写run方法,写上自己的代码
//3. run Thread 类实现了 Runnable 接口的 run 方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread {
int times = 0;
@Override
public void run() { //重写run方法,写上自己的逻辑代码
//该线程每隔一秒,在控制台输出“喵喵,我是小猫咪!”
while (true) {
System.out.println("喵喵,我是小猫咪!" + (++times) + "线程名=" + Thread.currentThread().getName());
//让该线程休眠1s
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (times == 10) {
break; //当times为10,退出 while 循环,这时线程也就退出了
}
}
}
}
输出结果如下:
同样,在多线程编程方面,不是意味着主方法结束了,这个进程就结束了,还要注意子进程的执行时间。主线程结束了,如果还有子线程还在运行,并不会造成应用程序的结束。
注意:start()
方法的调用后并不是立即执行多线程代码,而是使得该线程变为可运行态(Runnable)
,什么时候运行是由操作系统决定的。
从程序运行的结果可以发现,多线程程序是乱序执行。因此,只有乱序执行的代码才有必要设计为多线程。
Thread.sleep()
方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源,以留出一定时间给其他线程执行的机会。
实际上所有的多线程代码执行顺序都是不确定的,每次执行的结果都是随机的。
但是start()
方法重复调用的话,会出现java.lang.IllegalThreadStateException
异常。
Cat cat1=new Cat();
Cat cat2=cat1;
cat1.start();
cat2.start();
输出结果如下:
二、实现java.lang.Runnable
接口
采用Runnable
也是非常常见的一种,我们只需要重写run
方法即可,下面也来看个实例:
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建Cat对象,可以当做线程使用
new Thread(new Cat("cat1")).start();
}
}
class Cat implements Runnable {
private String name;
int times = 0;
public Cat(String name){
this.name = name;
}
@Override
public void run() { //重写run方法,写上自己的逻辑代码
//该线程每隔一秒,在控制台输出“喵喵,我是小猫咪!”
while (true) {
System.out.println("喵喵,我是小猫咪!" + (++times) + "线程名=" + Thread.currentThread().getName());
//让该线程休眠1s
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (times == 10) {
break; //当times为10,退出 while 循环,这时线程也就退出了
}
}
}
}
输出如下:
Cat
类通过实现Runnable
接口,使得该类有了多线程类的特征。run()
方法是多线程程序的一个约定。所有的多线程代码都在run
方法里面。Thread
类实际上也是实现了Runnable
接口的类。
在启动多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target)
构造出对象,然后调用Thread
对象的start()
方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread
的start()
方法来运行的。因此,不管是继承Thread
类还是实现Runnable
接口来实现多线程,最终还是通过Thread
的对象的API
来控制线程的,熟悉Thread
类的API
是进行多线程编程的基础。
三、Thread
和Runnable
的区别
如果一个类继承Thread
,则不适合资源共享。但是如果实现了Runable
接口的话,则很容易的实现资源共享。
实现Runnable
接口比继承Thread
类所具有的优势:
(1):适合多个相同的程序代码的线程去处理同一个资源
(2):可以避免java
中的单继承的限制
(3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立
(4):线程池只能放入实现Runable
类线程,不能直接放入继承Thread
的类
main
方法其实也是一个线程。在Java
中所有的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU
的资源。而在Java
中,每次程序运行至少启动2个线程。一个是main
线程,一个是垃圾收集线程。
四、线程状态转换
1、新建状态(New)
:新创建了一个线程对象。
2、就绪状态(Runnable)
:线程对象创建后,其他线程调用了该对象的start()
方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU
的使用权。
3、运行状态(Running)
:就绪状态的线程获取了CPU
,执行程序代码。
4、阻塞状态(Blocked)
:阻塞状态是线程因为某种原因放弃CPU
使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
(一)等待阻塞:运行的线程执行wait()
方法,JVM
会把该线程放入等待池中。(wait
会释放持有的锁)
(二)同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM
会把该线程放入锁池中。
(三)其他阻塞:运行的线程执行sleep()
或join()
方法,或者发出了I/O
请求时,JVM
会把该线程置为阻塞状态。当sleep()
状态超时、join()
等待线程终止或者超时、或者I/O
处理完毕时,线程重新转入就绪状态。(注意,sleep
是不会释放持有的锁)
5、死亡状态(Dead)
:线程执行完了或者因异常退出了run()
方法,该线程结束生命周期。
五、常用函数
①sleep(long millis)
: 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
②join()
:指等待t线程终止。
③yield()
:暂停当前正在执行的线程对象,并执行其他线程。
Thread.yield()
方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
yield()
应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()
的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()
达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
④setPriority()
: 更改线程的优先级。
⑤interrupt()
:不要以为它是中断某个线程!它只是线线程发送一个中断信号,让线程在无限等待时(如死锁时)能抛出抛出,从而结束线程
⑥wait()
wait
和sleep
:
共同点:
- 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。
wait()
和sleep()
都可以通过interrupt()
方法 打断线程的暂停状态 ,从而使线程立刻抛InterruptedException
。
不同点:
Thread
类的方法:sleep()
,yield()
等,Object
的方法:wait()
和notify()
等- 每个对象都有一个锁来控制同步访问。
Synchronized
关键字可以和对象的锁交互,来实现线程的同步。sleep
方法没有释放锁,而wait
方法释放了锁,使得其他线程可以使用同步控制块或者方法。 wait
,notify
和notifyAll
只能在同步控制方法或者同步控制块里面使用,而sleep
可以在任何地方使用所以sleep()
和wait()
方法的最大区别是:sleep()睡眠时,保持对象锁,仍然占有该锁;而wait()睡眠时,释放对象锁。
六、线程同步
1、synchronized
关键字的作用域有二种:
1)是某个对象实例内,synchronized aMethod(){}
可以防止多个线程同时访问这个对象的synchronized
方法(如果一个对象有多个synchronized
方法,只要一个线程访问了其中的一个synchronized
方法,其它线程不能同时访问这个对象中任何一个synchronized
方法)。这时,不同的对象实例的synchronized
方法是不相干扰的。也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized
方法;
2)是某个类的范围,synchronized static aStaticMethod{}
防止多个线程同时访问这个类中的synchronized static
方法。它可以对类的所有对象实例起作用。
2、除了方法前用synchronized
关键字,synchronized
关键字还可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}
,它的作用域是当前对象;
3、synchronized
关键字是不能继承的,也就是说,基类的方法synchronized f(){}
在继承类中并不自动是synchronized f(){}
,而是变成了f(){}
。继承类需要你显式的指定它的某个方法为synchronized
方法
把synchronized
当作函数修饰符时:
Public synchronized void methodA(){
//……
}
同步块:
public void method3(SomeObject so){
synchronized(so){
//……
}
}
将synchronized
作用于static
函数:
Class Foo{
public synchronized static void methodA(){ // 同步的static 函数
//……
}
public void methodB(){
synchronized(Foo.class) // class literal(类名称字面常量)
}
}
七、小讨论
在本次Java
大作业中,我们组做的是英雄杀的游戏,在实现方面采用了多线程的技术,但是在项目编写阶段,经常会遇到线程不执行的情况,而我们也是了解了很多Java
多线程些概念和一些注意事项,其中关于多线程中偶有线程不执行的情况,其实是因为我们的判断条件中使用了while(true)
来一直判断是否满足条件,经过查找资料,我们得出了下面这个小结论:
每次在创建的线程函数中,有while(true)
死循环的时候,在执行完一遍循环体的时候一般会使用sleep()
,使死循环不会一直占用CPU
资源。
while(true)
{
//do something
if(ret<0)
return;
else
{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
另外,当存在多个线程时,进程执行了多次,结果都不同,大概是线程间存在竞争关系,可以通过在线程中添加sleep()
函数来延长每个线程的执行时间,此时竞争会更激烈(可以想象成十字路口的两辆车,增加了车长,相撞的概率变大。)