多线程知识

Posted 技术很low的瓜贼

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多线程知识相关的知识,希望对你有一定的参考价值。

文章目录

多线程的学习与代码展示

线程的概念

  • 线程就是进程内部的程序流,操作系统内部是支持多进程的,而每个进程的内部又是支持多线程的,线程是轻量级的,新建线程会共享所在进程的系统资源
  • 多线程采用时间片轮转算法来保证多个线程的并发执行,(并发指在一个时间间隔内,有多个进程在执行)

线程的创建

  • java.lang.Thread类代表线程,任何线程对象都是Thread类(子类)的实例
  • Thread类是线程的模板,封装了复杂的线程开启等操作,封装了操作系统的差异性
  • 方法:
方法功能
Thread()使用无参的方式构造对象
Thread(String name)根据参数指定的名称来构造对象
Thread(Runnable target)根据参数指定的引用来构造对象,其中Runnable是个接口类型
Thread(Runnable target, String name)根据参数指定引用和名称来构造对象
void run()若使用Runnable引用构造了线程对象,调用该方法时最终调用接口中的版本
若没有使用Runnable引用构造线程对象,调用该方法时则啥也不做
void start()用于启动线程,Java虚拟机会自动调用该线程的run方法
  • 执行流程:
    • 执行main方法的线程叫做主线程,执行run方法的线程叫做新线程/子线程
    • main方法是程序的入口,对于start方法之前的代码来说,由主线程执行一次,当start方法调用成功后线程的个数由1个变成了2个,新启动的线程去执行run方法的代码,主线程继续向下执行,两个线程各自独立运行互不影响
    • 当run方法执行完毕后子线程结束,当main方法执行完毕后主线程结束
    • 两个线程执行没有明确的先后执行次序,由操作系统调度算法来决定

创建方式一

  • 自定义类继承Thread类并重写run方法,然后创建该类的对象调用start方法

继承Thread类的方式代码简单,但是若该类继承Thread类后则无法继承其它类,而实现Runnable接口的方式代码复杂,但不影响该类继承其它类以及实现其它接口,因此以后的开发中推荐使用第二种方式

代码:

/**
 * 多线程创建的方式一
 * extends Thread
 * 缺点:java只支持单继承,无法再继承别的类
 */
public class ThreadRunTest extends Thread

    @Override
    public void run() 
        for (int i=0; i<20; i++) 
            System.out.println("子线程中的打印结果为" + i);
        
    

    public static void main(String[] args) 
        // 声明Thread类型的引用指向子类类型的对象形成多态
        ThreadRunTest t1 = new ThreadRunTest();

        // t1.run();

        // 启动线程,java虚拟机会自动调用该线程中的run方法
        t1.start();

        for (int i=0; i<20; i++) 
            System.out.println("-------------------主线程中的打印结果" + i);
        
    

创建方式二

  • 自定义类实现Runnable接口并重写run方法,创建该类的对象作为实参来构造Thread类型的对象,然后使用Thread类型的对象调用start方法

代码:

/**
 * 多线程的创建方式二
 * implements Runable
 */
public class RunableRunTest implements Runnable
    @Override
    public void run() 
        for (int i=0; i<20; i++) 
            System.out.println("子线程中的打印结果为" + i);
        
    

    public static void main(String[] args) 
        RunableRunTest rrt = new RunableRunTest();

        Thread t1 = new Thread(rrt);
        // 使用该方法调用run时,最终调用的是接口中的版本
        t1.start();

        for (int i=0; i<20; i++) 
            System.out.println("-------------------主线程中的打印结果" + i);
        

    

创建方式三:

  • 创建线程的第三种方式为实现java.util.concurrent.Callable接口。

代码:

/**
 * 线程的第三种创建方式
 */
public class CallableRunTest implements Callable 
    @Override
    public Object call() throws Exception 
        int sum = 0;
        for (int i = 1; i <= 100; i++) 
            sum += i;
        
        System.out.println(sum);
        // 自动装箱拆箱技术
        return sum;
    

    public static void main(String[] args) 
        CallableRunTest crt = new CallableRunTest();
        // 获取方法调用后的返回结果
        FutureTask futureTask = new FutureTask(crt); // FutureTask间接实现了Runnable接口

        Thread thread = new Thread(futureTask);
        thread.start();
        try 
            System.out.println("结果为" + futureTask.get());
         catch (InterruptedException e) 
            e.printStackTrace();
         catch (ExecutionException e) 
            e.printStackTrace();
        
    

创建方式四(可以算作第四种方式)

  • 线程池方法

代码:

/**
 * 线程池的使用
 * 可以算作线程的第四种创建方式
 */
public class ThreadPoolTest 

    public static void main(String[] args) 
        // 1、创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 2.向线程池中布置线程
        executorService.submit(new CallableRunTest());

        // 3.关闭线程池
        executorService.shutdown();
    


Thread和Runnable匿名内部类方式

Thread匿名内部类方式

代码1:

// 使用继承+匿名内部类的方式创建并启动线程
    public static void noName1() 
        Thread t1 = new Thread() 
            @Override
            public void run() 
                System.out.println("继承+匿名内部类");
            
        ;
        t1.start();
    

代码2:

// 优化:使用继承+匿名内部类的方式创建并启动线程
    public static void noName11() 
        new Thread() 
            @Override
            public void run() 
                System.out.println("优化 : 继承+匿名内部类");
            
        .start();
    

Runnable匿名内部类方式

代码1:

// 使用接口+匿名内部类方式创建并启动线程
    public static void noName2() 
        Runnable r1 = new Runnable() 
            @Override
            public void run() 
                System.out.println("接口+匿名内部类");
            
        ;
        Thread t12 = new Thread(r1);
        t12.start();

    

代码2:

// 优化:使用接口+匿名内部类方式创建并启动线程
    public static void noName22() 
        new Thread(new Runnable() 
            @Override
            public void run() 
                System.out.println("优化 : 接口+匿名内部类");
            
        ).start();
    

Thread和Runnable的Lambda方式

Thread + Lambda

代码:

// Lambda + Thread创建线程并启动
    public static void Lambda1() 
        new Thread(() -> 
            System.out.println("lambda+Thread");
        ).start();
    

Runnable + Lambda

代码:

// Lambda + Runable构建多线程并启动
    public static void Lambda2() 
        Runnable ra = () -> 
            System.out.println("Lambda + Runnable");
        ;
        Thread t3 = new Thread(ra);
        t3.start();
    

线程的生命周期

  • 新建状态 : 使用new关键字创建之后进入的状态,此时线程并没有开始执行
  • 就绪状态 : 调用start方法后进入的状态,此时线程还是没有开始执行
  • 运行状态 : 使用线程调度器调用该线程后进入的状态,此时线程开始执行,当线程的时间片执行完毕后任务没有完成时回到就绪状态
  • 消亡状态 : 当线程的任务执行完成后进入的状态,此时线程已经终止
  • 阻塞状态 : 当线程执行的过程中发生了阻塞事件进入的状态,如:sleep方法,阻塞状态解除后进入就绪状态

线程的编号和名称

方法功能
long getId()获取调用对象所表示线程的编号
String getName()获取调用对象所表示线程的名称
void setName(String name)设置/修改线程的名称为参数指定的数值
static Thread currentThread()获取当前正在执行线程的引用

演示代码1:

/**
 * 获取修改线程ID和Name
 */
public class MethodTest extends Thread

    public MethodTest(String name) 
        super(name);
    

    @Override
    public void run() 
        System.out.println("旧ID:" + getId() + ", 旧Name:" + getName());
        setName("tb");
        System.out.println("新ID:" + getId() + ", 新Name:" + getName());
    

    public static void main(String[] args) 
        MethodTest mt = new MethodTest("gyt");
        mt.start();

        // 获取当前正在执行线程的引用
        Thread t1 = currentThread();
        System.out.println("主线程ID:" + t1.getId() + ",主线程Name:" + t1.getName());
    

演示代码2:

public class MethodTest2 implements Runnable
    @Override
    public void run() 
        Thread t1 = Thread.currentThread();
        System.out.println("旧ID:" + t1.getId() + ", 旧Name:" + t1.getName());
        t1.setName("tb");
        System.out.println("新ID:" + t1.getId() + ", 新Name:" + t1.getName());
    

    public static void main(String[] args) 
        MethodTest2 methodTest = new MethodTest2();
        Thread t2 = new Thread(methodTest, "gyt");
        t2.start();

        Thread t3 = Thread.currentThread();
        System.out.println("主线程ID:" + t3.getId() + ",主线程Name:" + t3.getName());
    

线程的常用方法

方法功能
static void yield()当前线程让出处理器(离开Running状态),使当前线程进入Runnable状态等待
static void sleep(times)使当前线程从 Running 放弃处理器进入Block状态, 休眠times毫秒, 再返回到Runnable如果其他线程打断当前线程的Block(sleep), 就会发生 InterruptedException。
int getPriority()获取线程的优先级
void setPriority(int newPriority)修改线程的优先级。优先级越高的线程不一定先执行,但该线程获取到时间片的机会会更多一些
void join()等待该线程终止
void join(long millis)等待参数指定的毫秒数
boolean isDaemon()用于判断是否为守护线程
voidsetDaemon(booleanon)用于设置线程为守护线程

以上是关于多线程知识的主要内容,如果未能解决你的问题,请参考以下文章

详解C++多线程

线程池怎么保证线程按次序执行任务?

C++内存序

深入理解Java多线程 - Java并发编程的艺术

操作系统:进程间的相互作用(多线程基础)

java多线程问题 我很好奇这两个结果是怎么运行出来的,我知道产生这种结果差异的原因在红线出。