栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

2.线程的创建,状态及常用方法-bite

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

2.线程的创建,状态及常用方法-bite

线程的创建及常用方法
  • java中常使用多线程进行并发编程
  • 1.重写Thread类的run方法创建线程
  • 2.创建一个类继承Runnable接口并将其实例传给Thread实例
  • 3./4.使用匿名内部类
  • 5.lambda(第四种的延伸):使用lambd代替Runnable
  • 线程的状态getState()
    • NEW: 安排了工作, 还未开始行动
    • RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
    • BLOCKED: 这几个都表示排队等着其他事情
    • WAITING: 这几个都表示排队等着其他事情
    • TIMED_WAITING: 这几个都表示排队等着其他事情
    • TERMINATED: 工作完成了.
  • 多线程可以提高任务完成效率(有时不能)
  • Thread常见构造方法
  • Thread类的其他属性和方法
  • 线程的创建/线程的终止/线程的等待/线程获取引用/线程的休眠
    • 启动一个线程-start()
    • 终断线程Thread.currentThread().isInterrupted()
    • 线程等待join()
    • Thread.crurendThread()那个线程调用,就获取到谁的实例
    • 线程的休眠sleep

java中常使用多线程进行并发编程

操作系统中提供了一组关于线程的C语言风格的API,java对其进一步封装,就成了Thread类
java标准库中提供了Thread类,来表示和操作线程,可以视为java标准库提供的API.

一个进程中至少有一个线程

1.重写Thread类的run方法创建线程

重写的run方法中描述了线程要执行的代码,每个线程都是并发执行,因此要告诉这个线程要执行的代码是什么,在run方法中只是在安排要执行的工作,并没有实施.

package thread;

class MyThread2 extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Thread t = new MyThread2();
        t.start();

        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

创建Thread实例时,就已经吧任务创建好了,t.start()正式开始执行

这里调用的start方法才是真正在系统中创建了线程并开始执行run方法,在调用start之前系统是没有创建出线程的,这是在同一个进程中创建线程,

自己创建的t线程和自动创建的main线程,就是并发关系:
此处的并发=并行+并发.宏观上是区分不了并行和并发的.都取决于系统内部的调度~

注意:
sleep这个事情到了ms级并不是那么精确的!!!
sleep 1000不是说正好1000ms之后就上cpu,意思1000之内你上不了cpu, sleep 1000写了之后,可能是1006才上的cpu
sleep 1001写了之后,可能是1002就上了cpu~~

输出如下:

现在两个线程,都是打印一条,就休眠个1s~当1s 时间到了之后,系统先唤醒谁呢?看起来这个顺序不是完全确定(随机的)
每一轮,1s 时间到了之后,到底是先唤醒main还是 thread,这是不确定的(随机的)
操作系统来说,内部对于线程之间的调度顺序,在宏观上可以认为是随机的(抢占式执行)

2.创建一个类继承Runnable接口并将其实例传给Thread实例

通过Runnable来描述任务内容,并将其交给Thread实例

// Runnable 就是在描述一个 "任务"
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello");
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

3./4.使用匿名内部类

通常认为Runnable这种写法跟好一点,更好的解耦
Runnable单纯的只是描述了一个任务~至于这个任务是要通过一个进程来执行,还是线程来执行,还是线程池来执行,还是协程来执行,Runnable本身并不关心.Runnable 里面的代码也不关心.

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        };
        t.start();
    }
}

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        });
        t.start();
    }
}

5.lambda(第四种的延伸):使用lambd代替Runnable
public class Demo6 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello thread");
        });
        t.start();
    }
}

线程的状态getState()

NEW: 安排了工作, 还未开始行动

已经创建好了Thread对象,但还没有调用 start

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
             
        });
        System.out.println(t.getState());
        t.start();
    }
}

java内部状态,和操作系统中PCB里的状态没啥关系

RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.

就绪状态:处于这个状态的线程,就是在就绪队列中.随时可以被调度到CPU 上
如果代码中没有进行sleep,也没有进行其他的可能导致阻塞的操作代码大概率是处在Runnable状态的

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
}
BLOCKED: 这几个都表示排队等着其他事情

当前线程在等待锁,导致了阻塞(阻塞状态之一)
synchronized

WAITING: 这几个都表示排队等着其他事情

当前线程在等待唤醒,导致了阻塞(阻塞状态之一)wait

TIMED_WAITING: 这几个都表示排队等着其他事情

代码中调用了 sleep,就会进入到TIMED_WAITINGjoin(超时时间)
意思就是当前的线程在一定时间之内,是阻塞的状态

public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                // 这里啥都不能有!!!
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
}
TERMINATED: 工作完成了.
public class Demo14 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                // 这里啥都不能有!!!
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState());
    }
}

操作系统中的线程已经执行完毕,销毁了,但是Thread对象还在
java内部状态,和操作系统中PCB里的状态没啥关系

多线程可以提高任务完成效率(有时不能)

多线程特别适合于那种CPU密集型的程序.
程序要进行大量的计算,使用多线程就可以更充分的利用CPU的多核资源~~

Thread常见构造方法


也可以使用jconsole观察线程名字

Thread类的其他属性和方法


getId():ID 是线程的唯一标识,不同线程不会重复

getName():名称是各种调试工具用到

getState():状态表示线程当前所处的一个情况,下面我们会进一步说明

getPriority():优先级高的线程理论上来说更容易被调度到

isDaemon():关于后台线程,需要记住一点:JVM会在一个进程的所有非后台线程结束后,才会结束运行。如果线程是后台线程,就不影响进程退出.如果线程不是后台线程(前台线程),就会影响到进程退出心~创建的t1和t2默认都是前台的线程,即使main方法执行完毕,进程也不能退出.得等t1和t2都执行完,整个进程才能退出!!!如果t1和t2是后台线程此时如果main执行完毕,整个进程就直接退出, t1和t2就被强行终止了

isAlive():是否存活,即简单的理解,为 run 方法是否运行结束了

isInterrupted():线程的中断问题

线程的创建/线程的终止/线程的等待/线程获取引用/线程的休眠 启动一个线程-start()

决定系统是不是真的创建出线程
start和run的区别:
run只是一个普通的方法,描述了任务的内容,在main线程中调用run并没有创建新的线程

public class Demo9 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // t.start();
        t.run();

        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
终断线程Thread.currentThread().isInterrupted()

核心思路是让线程中的run方法执行完

Thread.interrupted():这是一个静态方法
Thread.crurentThread.isInterrupted():这是实例方法,其中currentThread能够获取到当前线程的实例
区别:
Thread.interrupted()这个方法判定的标志位是Thread的static成员.(一个程序中只有一个标志位)
Thread.currentThread().isInterrupted(这个方法判定的标志位是Thread的普通成员.每个示例都有自己的标志位.一般无脑使用这个

public class Demo11 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 当触发异常之后, 立即就退出循环~
                    System.out.println("这是收尾工作");
                    break;
                }
            }
        });
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 在主线程中, 调用 interrupt 方法, 来中断这个线程.
        // t.interrupt 的意思就是让 t 线程被中断!!
        t.interrupt();
    }
}

调用t.interrupt()会产生两种情况:
1.如果t线程是就绪状态,调用后线程的标志位(Thread.currentThread().isInterrupted())变为true

2.如果t线程处在阻塞状态(sleep休眠),就会触发一个InterruptException异常,而此代码一旦触发异常后,进入catch中后,仅单纯打印一个日志,然后继续执行,没有起到终止线程的作用,所以在上述代码中的catch中加入break来跳出循环

线程等待join()

线程之间的调度是无序的,需要控制线程的执行顺序,线程等待是其中一种手段

public class Demo12 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        // 在主线程中就可以使用一个等待操作. 来等待 t 线程执行结束.
        try {
            t.join(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

t.join() 调用者等待被调用者,等待被调用者执行完毕后,再继续往下执行

但是 join() 默认情况下是死等,(不合理)
可以用 join(ms) 时间之内被调用线程结束直接返回,超过时间也直接返回

Thread.crurendThread()那个线程调用,就获取到谁的实例 线程的休眠sleep

进程, PCB+双向链表这个说法是针对只有一个线程的进程,是如此的

如果是一个进程有多个线程, 此时每个线程都有一个PCB,一个进程对应的就是一组PCB 了

PCB上有一个字段tgroupld,这个id 其实就相当于进程的id.同一个进程中的若干个线程的tgroupld是相同的!!!

process control block是进程控制块?和线程有啥关系?其实 Linux内核不区分进程和线程.进程线程是程序猿写应用程序代码,搞出来的词.实际上Linux内核只认PCB !!!在内核里Linux把线程称为轻量级进程
PCB上有一个字段 tgroupld,这个id其实就相当于进程的id.同一个进程中的若干个线程的 tgroupld是相同的!!!

PCB上有一个字段 tgroupld,这个id其实就相当于进程的id.同一个进程中的若干个线程的 tgroupld是相同的!!!

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/978687.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号