Java线程基本介绍

最新推荐文章于 2024-06-04 10:12:53 发布

不帅的小齐

最新推荐文章于 2024-06-04 10:12:53 发布

阅读量306

点赞数

文章标签： java 面试

本文链接：https://blog.csdn.net/qq_38104145/article/details/127515007

版权

近期在学习Java线程，也是从基础开始再重新回顾一遍，顺便做个笔记整理下思路，个人也是看网上视频加上个人理解，若有错误还请广大网友指正，共同进步。

1 线程的相关概念

1.1 进程和线程

1 进程：进程就是运行中的程序，启动一个线程后，操作系统就是为该进程分配一个内存空间。如图：

2 线程：线程是由进程创建的，是进程的一个实体。一个进程可以拥有多个线程。可以理解为一个进程包含一个或者多个线程。

1.2 并发与并行

1 并发：同一时刻，多个任务交替执行，造成一种貌似同时的错觉。单核cpu实现的多任务就是并发。

2 并行：同一时刻，多个任务同时执行，多核cpu可实现并行。

帮助记忆理解：

并发的“发”，可理解为发生，同一时刻有多件事情要发生，你一个人（单核CPU）要全部将其解决。

并行的“行”，可以理解为共同行走，你和你的好朋友一起散步，两个人是同时往前走的。

2 线程运行的过程（以Java为列）

线程的实现有两种方式，一种是继承Thread线程类的方式，如下：

//继承Thread线程类
class Cat extend Thread{/*******/}

public static void main(String[] args) {
   Cat cat=new Cat();
   cat.start();  //启动一个子线程
}

另一种是类B实现Runnable的接口，如下：

//实现Runnable接口
class Dog implements Runnable{/********/}

public static void main(String[] args) {
   Dog dog = new Dog();
   Thread thread = new Thread(dog);//创建了Thread对象，把 dog对象(实现Runnable),放入Thread
   dog.start();  //启动一个子线程
}

下面将根据这两种方法具体介绍。

2.1 继承Thread线程实现线程

当程序执行时，之后开启main方法这个主线程，则进行一个进程的执行，若有子线程，子线程A.start()开启一个子线程，当主线程和子线程全部执行完毕，进程结束。注意：只有所有的线程结束，进程才会结束。这样说可能很难理解，上代码：

public class Thread01 {

    public static void main(String[] args) throws InterruptedException{
        Cat cat=new Cat(); //创建Cat对象，可以当作线程使用
        cat.start(); //启动子线程
        //说明：当main线程启动一个子线程 Thread-0,主线程不会阻塞，会继续执行，这时 主线程和子线程会交替执行
        System.out.println("主线程继续执行"+Thread.currentThread().getName());
        for (int i = 0; i <10 ; i++) {
            System.out.println("主线程 i="+i);
            Thread.sleep(1000);
        }
    }
}

/*
1 当一个类继承了Thread类，该类就可以当作线程类使用
2 我们会重写run方法，写上自己的业务代码
3 Thread类 内部也是实现了 Runnable 接口的run方法
*/
class Cat extends Thread{

    int times=0;
    @Override
    public void run() {
        while (true){
            //该线程每隔1秒种，在控制台输出 “喵喵，我是小喵喵”
            System.out.println("喵喵，我是小喵喵 "+(++times)+" 线程名="+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times==80){
                break; //当times到80，退出while,这时线程也就退出。。。
            }
        }
    }
}

上述的代码中，其中main()方法，即为一个主线程。cat.start()，即启动了一个子线程，在主线程和子线程同时运行时，无论时主线程先结束还是子线程先结束，进程都不会停止。全部线程结束时，整个进程才会停止。上述代码可以直接复制运行，可以实际的观察一下。

2.2 实现Runnable接口实现线程

class Dog implements Runnable { //通过实现Runnable接口，实现线程
    int count = 0;
    @Override
    public void run() { //普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);  //休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Thread thread = new Thread(dog); //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
        thread.start(); //启动一个子线程
    }
}

代码之后，看一个流程图：

1 Thread thread =newThread(dog); 在Thread类的具体内部实现中会发现也是实现了Runnable的接口：

2 将dog对象放进Thread中，之后通过thread.start()的方式启动线程。

2.3 继承Thread VS 实现Runnable的区别

1 从Java设计来看，通过继承Thread或者实现Runnable接口创建线程本质上没有区别，从jdk帮助文档上看Threrad类本身就是实现了Runnable接口。

2 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable。

3 如何终止线程

3.1 任务执行结束

当任务执行结束，线程会终止。

3.2 线程通知方式

还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式。上代码：

class T extends Thread{
    int count=0;
    //设置一个控制变量
    private boolean loop=true;
    @Override
    public void run() {
        while (loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中... "+(++count));
        }
    }
    //通过set的方法来设置线程是否执行
    public void setLoop(boolean loop){
        this.loop=loop;
    }
}

public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去t1 线程终止，必须可以修改loop
        //让t1 退出run方法，从而终止 t1线程-> 通知方式
        Thread.sleep(10000); //休眠10秒，在退出
        t1.setLoop(false);
    }
}

3.3 线程中断

1 线程中断是一种协作机制，线程可以通过这种机制来通知另一个线程，告诉它在合适的或者可能得情况下停止当前工作。

2 每个线程都有一个boolean类型的中断变量，并且在Thread类中有三个方法，分别是。

public class Thread{
    public void interrupt(){...}
    public boolean isInterrupted(){...}
    public static boolean interrupted(){...}
    ...
}

1 interrupt()方法可以被其他线程进行调用，通过将中断变量设置为true来中断线程。

2 isInterrupted() 方法返回线程的中断变量状态，但不会改变其状态值。

3 interrupted() 方法会先清除中断状态，即将中断变量设为false,并返回之前的中断状态。

3.3.1 如何理解中断机制

中断操作（即调用线程的interrupte()方法）并不是会停止一个正在运行的线程，它只是把线程里边的中断变量设置为true，向这个线程发出一个中断请求，而线程怎么反应，则是线程自己的事情。它可以完全不理会中断，照常执行。

3.3.2 如何恢复中断

并不是把线程从BLOCKED或WAITING等状态中解救出来（本来中断也不是这么个意思），而是把线程的中断状态变量重新设置为True。

4 线程常用的方法

4.1 常见方法

1 setName //设置线程名称，使之与参数name相同
2 getName //返回线程的名称
3 start //是该线程开始执行；java虚拟机底层调用该线程的start0()方法
4 run //调用该线程的run方法
5 setPriority //更改线程的优先级
6 getPriority //获取线程的优先级
7 sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
8 interrupt //中断线程，不是停止,一般用于正在休眠的线程
9 线程优先级：MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY

4.2 线程礼让

1 yield线程礼让，让出cpu，让其他线程执行，但是礼让的时间不确定，所以也不一定礼让成功。

4.2 线程插队

join 线程的插队，插队的线程一旦成功，则肯定先执行插入的线程所有任务。

class T2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000); //休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程（大哥）吃了 "+i+" 个包子");
        }
    }
}

public static void main(String[] args) throws InterruptedException {
        T2 t2=new T2();
        t2.start();
        for(int i=0;i<20;i++){
            Thread.sleep(1000);
            System.out.println("主线程（小弟）吃了 "+i+" 个包子");
            if (i==5){
                System.out.println("主线程（小弟）让(大哥)先吃");
                // join 线程插队 一定会成功
                // t2.join();
                // 礼让 不一定会成功
                Thread.yield();
                System.out.println("子线程（老大）吃完了，我们接着吃");
            }
        }
}