多线程的操作

DJ懒羊羊。

已于 2023-07-25 10:39:49 修改

阅读量70

点赞数 1

分类专栏： java 文章标签： java 开发语言

于 2023-07-25 10:36:07 首次发布

本文链接：https://blog.csdn.net/weixin_65492194/article/details/131909612

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

孩儿立志出乡关,学不成名誓不还.

一:线程的创建

1:线程的创建总共分为5种方式

a):创建一个类,这个类继承于Thread类

b):创建一个类,这个类实现Runnable接口

c):创建一个类,这个类继承于Thread类,基于匿名内部类

d):创建一个类,这个类实现Runnable接口,基于匿名内部类

e):基于lambda表达式.

a):第一种方式

class MyThread extends Thread{ 
@Override   
 public void run() {
        System.out.println("hello world");
          try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

    }
}

public class Demo1 {
    public static void main(String[] args) {
       MyThread myThread=new MyThread();
       myThread.start();
       //myThred.run();//run是一个普通的方法,并没有创建出来的真正的线程来.
           while(true){
           System.out.println("hello main");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
       }
    }
}

注意:

1:run方法为线程执行的入口,即这个多线程要干什么事情,线程的核心代码在这里进行体现.

2:start方法为创建线程,此时,告诉操作系统要调用底层的API,创建线程,即1):创建PCB,再将PCB添加到双向链表中,操作系统内核调用底层的数据结构进行操作.

3:如果用我们创建对象的实例化去调用run方法会不会创建线程?

不会,因为run方法是成员行为,此时,只是简单调用了一下成员方法,并没有创建线程,也没有让操作系统调用底层的API进程操作.

运行结果:

说明:在前面的一篇博客中,我们提到了多线程是为了解决"并发编程",提高并发编程的效率.

在这个程序中,有两个线程,一个是主线程,一个是我们自己创建的线程.

在main方法中有一个while循环,在线程run里面也有一个while循环,两个循环都是死循环.

两个循环都在打印,两个线程分别执行自己的循环,两个线程都参与到cpu的调度中,能够并发执行.

在自己创建的thread类中,调用start静态方法,创建新的线程,此时run为线程的执行入口,执行里面的方法,新线程和主线程并发执行,即新线程和主线程放在同一个进程中,并发进行执行,进行交叉打印.

b):第二种方式

class MyRunnable implements  Runnable{
    @Override    public void run() {
        while(true){
            System.out.println("hello world");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

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

c):第三种方式

public class Demo3 {
    public static void main(String[] args) {
        Thread t=new Thread(){
            @Override            
             public void run() {
                while(true){
                    System.out.println("hello Thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();

    }
}

匿名内部类:

匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口.

针对上述程序,我们创建了一个子类,这个子类没有名字,但是继承于Thread类,另一方面,这个类在demo3的下面,在子类中重写了run方法并且创建了该子类的实例,t引用指向.

d):第四种方式

4.实现Runnable,重写run,基于匿名内部类
public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(new Runnable() {
            @Override          
              public void run() {
                while(true){
                    System.out.println("hello Thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

e):第五种方式 (推荐)

5:使用lambda表达式,表示run方法的内容------推荐使用
public class Demo5 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t.start();
    }
}

f):线程---起别名

public class Demo6 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            while(true){
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"MyThread");
        t.start();
    }
}
//基于lambda起别名,格式Thread 线程对象=new Thread(()->{run方法},名字)

运行结果:

我们利用线程软件来观察线程的状态.

在结果中,我们并没有发现main线程,为什么呢?

原因:在执行线程的时候,由于是并发执行,两个线程都会执行,在执行的时候,由于我们自己创建的线程,进入到run里面是while循环,即陷入死循环.而main线程在走完之后就会结束,所以我们在线程查看器查看不到main线程的存在.

二:线程的常见属性


属性	方法备注
ID	getID() 在JVM中识别线程的设定的标识针对线程的PCB还有唯一标识pid 上面的两种是相互独立的
name	getName() 获取线程的名字
状态	getState() 获取线程的状态
优先级	getPriority() 优先级高会优先被调用到
是否后台线程	isDaemon() JVM会在线程的所有非后台线程结束后,才会结束进行
是否存活	isAlive() 是否存活,为run方法是否运行结束 Thread对象/对应的线程(系统内核中)是否存活一般的,Thread对象创建好,手动调动start,内核才真正创建出线程. thread对象和内核中的线程消亡无法确定.
是否被中断	isInterrupted 线程是否被中断