Java中的线程

坚持拒绝熬夜

已于 2024-09-20 18:33:09 修改

阅读量741

点赞数 7

文章标签： java 开发语言

于 2024-09-10 19:44:24 首次发布

本文链接：https://blog.csdn.net/weixin_72779762/article/details/142103089

版权

Java代码创建线程

1.使用继承Thread,重写run的方式来创建线程

package threading;
class MyThread extends Thread{
    @Override
    public void run() {
        while (true){
                System.out.println("t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {//主线程
        Thread t = new MyThread();
        t.start();//创建一个新的线程
        t.run();//没有创建线程
        while (true){
            System.out.println("main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

⒉使用实现Runnable,重写run

package threading;
class MyRunnable implements Runnable{

    @Override
    public void run() {

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

Runnable类是具体描述一个任务,通过run方法进行描述

这里的1和2都是通过run来描述线程的入口,其中2是使用Runnable interface来描述

3.继承 Thread,使用匿名内部类

package threading;

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){//匿名内部类
            @Override
            public void run() {
                while (true){
                    System.out.println("t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
    }
}

4.实现 Runnable,使用匿名内部类

package threading;

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"66哥");
    }
}

其中的66哥代表的是线程的名字,可以用jconsole.exe后台监控线程的运行

5.使用lambda表达式(最推荐的,前面的了解了解即可)

package threading;

public class ThreadDemo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread( () -> {
            while (true){
                System.out.println("t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while(true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

细节与解释

1.其中这个程序中有一个main线程和一个自己新开的线程,与main线程并发执行

2.通过t.start创建新的线程,每个线程都是单独的执行流

3.如lambda表达式中的代码会不断打印main和t交替

我当时疑惑的点

1.其中run方法是入口方法,他是属于线程启动的入口,你创建一个新的线程就一定会调用run方法系统会自动调用

thread的方法以及属性

1.thread的构造方法

2.thread里的一些状态

1.每个线程都有自己独有的状态,优先级,上下文以及记账信息

2.其中解释一下后台线程

true是后台线程

false是前台线程

前台线程会阻止Java进程的结束,必须Java所有的前台线程执行完了Java进程才能结束

创建的线程默认是前台线程,可以通过setDaemon方法设置成后台线程

线程的中断

如这行代码通过设置全局变量来控制线程里的运行与否

疑问? 如果改成局部变量是否还可以正常工作呢???

是不可以的,这涉及到变量捕获

在lambda表达式可以捕获和使用外部的变量,前提这些变量是有效最终变量,也就是final修饰的变量,为了确保线程的安全

因为lambda表达式捕获外部变量后就会存起来,不会去再读取这个变量,一旦修改了这个外部变量,lambda表达式并不会去读取,所以要选取final所修饰的变量

Java线程内部方法部分举例与细节

中断

package threading;

public class ThreadDemo6 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t");
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }
}

但是运行发现抛出异常后一样继续执行

原因

1.interrupt方法的作用是

1)设置标志位为true

2)如果线程在阻塞中(如正在sleep中),会被唤醒,通过抛出异常让sleep立即结束

2.其次

当sleep被唤醒的时候,sleep会将isInterrupt的标志位自动清空,也就是true -> false,因为这样才导致抛出异常后程序继续执行了

等待一个线程-join()

由于线程之间是并发执行的,操作系统对线程的调度是无序的,无法判断线程谁先执行谁先结束,所以引入join()

public class ThreadDemo7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
                System.out.println("t");
        });
    t.start();
    t.join();
    System.out.println("main");
    }
}

使用t.join(),使t线程执行完以后才可以执行main线程的内容

也就是说t线程没有结束的话,main线程就会进入阻塞等待的状态

细节!!!

只是让main线程需要等待t线程执行结束之后才可以执行,其他线程并不受影响,可以正常调度

如果t线程已经结束了,调用join()并不会阻塞main线程

join()还可以写一个参数,即等待的最大时间,等太久就不等了

线程的状态

六大状态

NEW 系统中的线程还没创建出来呢,只是有个Thread对象
TERMINATED 系统中的线程已经执行完了,Thread 对象还在
RUNNABLE 处于就绪状态正在CPU上运行准备好随时可以去CPU上运行.
TIMED_WAITING 指定时间等待. sleep方法
BLOCKED 表示等待锁出现的状态.
WAITING 使用wait方法出现的状态