多线程的操作

简介: 多线程的操作

一:线程的创建

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   线程是否被中断

对于各个属性的进一步说明

相关文章
|
5月前
|
大数据 C#
C#实现多线程的几种方式
C#实现多线程的几种方式
|
6月前
|
安全 C++
C++多线程编程:并发与同步
C++多线程编程:并发与同步
42 0
多线程的线程工具的初步使用和原理详解
多线程的线程工具的初步使用和原理详解
74 0
|
Java 调度
多线程学习之多线程的三种实现方式及应用
多线程学习之多线程的三种实现方式及应用
57 0
|
Java Linux API
【多线程】初识线程,基础了解
认识线程、了解Thread类及常见方法、线程状态
|
存储 Java C++
多线程的2种实现方式
多线程的2种实现方式
103 0
|
设计模式 存储 安全
多线程(六):多线程案例
多线程(六):多线程案例
116 0
多线程(六):多线程案例
|
Linux API 调度
C++之多线程(一)
C++进阶之多线程上
120 0
多线程之常见方法使用
线程是程序执行的最小单位,而进程是操作系统分配资源的最小单位;进程是系统资源分配的单位,线程是系统调度的单位。一个进程由一个或多个线程组成,线程是一个进程中代码的不同执行路线;进程之间相互独立,进程之间不能共享资源,而线程共享所在进程的地址空间和其它资源。同时线程还有自己的栈和栈指针,程序计数器等寄存器。
|
缓存 调度 芯片
同步多线程
<div id="card-container" class="mod-top" style="clear:both"> <div class="card-summary nslog-area clearfix"> <div class="card-summary-content"> <div class="para">同步多线程(SMT)是一种在一个CPU 的<a target="
1696 0