Java多线程

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()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Threadstart()方法来运行的。因此,不管是继承Thread类还是实现Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。

三、ThreadRunnable的区别

如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势:

(1):适合多个相同的程序代码的线程去处理同一个资源

(2):可以避免java中的单继承的限制

(3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立

(4):线程池只能放入实现Runable类线程,不能直接放入继承Thread的类

main方法其实也是一个线程。在Java中所有的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU的资源。而在Java中,每次程序运行至少启动2个线程。一个是main线程,一个是垃圾收集线程。

四、线程状态转换

img

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

waitsleep
共同点:

  1. 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。
  2. wait()sleep()都可以通过interrupt()方法 打断线程的暂停状态 ,从而使线程立刻抛InterruptedException

不同点:

  1. Thread类的方法:sleep(),yield()等,Object的方法:wait()notify()
  2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互,来实现线程的同步。sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法。
  3. waitnotifynotifyAll只能在同步控制方法或者同步控制块里面使用,而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()函数来延长每个线程的执行时间,此时竞争会更激烈(可以想象成十字路口的两辆车,增加了车长,相撞的概率变大。)

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值