基础线程知识-CSDN博客

本文链接：https://blog.csdn.net/m0_59091195/article/details/132336737

线程

1、什么是线程？

线程是CPU执行任务的最小单元，也是程序内部的一条执行路径。

我们之前启动程序后，main方法执行其实就是一条单独的执行路径，程序中如果只有一条执行路径的话，那么他就是单线程的程序。

public static void main(String[] args) {
Student stu = new Student();
    stu.setAge(99);
        stu.setHeight(1000);
}

2、多线程是什么？

多线程就是从软硬件上实现多条执行流程的技术。

3、java是通过java.lang.Thread类来代表线程的，按照面向对象的思想，Thread类提供了实现多线程的方式。

4、线程的创建方式

多线程的实现方案一：继承Thread类

(1)定义一个子类MyThread继承线程类java.lang.Thread,重写Run()方法；

(2)创建MyThread类的对象；

(3)调用对象的start()方法启动线程；

优点：编码简单

缺点：线程已经继承Thread,无法继承其他类，不利于扩展。

多线程的实现方案二：

（1)定义一个任务类MyRunnable实现Runnable接口，重写run()方法；

(2)创建Runnable任务对象；

（3）把Runnable任务对象交给Thread处理；

(4)调用线程的Start()方法启动线程；

优点：扩展性强

缺点：线程有执行结果的话是不可以返回的

多线程的实现方案三:

利用Runnable匿名内部类方式；

代码演示

package com.DarkHorse;

public class Main3 {

    public static void main(String[] args) {
        Runnable target = new Runnable() {

            @Override
            public void run() {
                for(int i=0;i<100;i++) {
                    System.out.println("子线程执行输出"+i);
                }
            }
        };
        Thread s=new Thread(target);
        new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i=0;i<100;i++) {
                    System.out.println("子线程执行输出"+i);
                }
            }
        }).start();
        for(int i =0;i<100;i++) {
            System.out.println("第三个线程执行");
        }

            new Thread(()->{
                for(int i =0;i<100;i++) {
                    System.out.println("线程和运行"+i);
                }
            }).start();
}
}

多线程的实现方案四:

利用Callable、FutureTask接口实现得到任务对象

(1)定义类实现Callable接口，重写call方法，封装要做的事情

(2)用FutureTask把Callable对象封装成线程任务对象。

把线程任务对象交给Thread处理

调用Thread的start方法启动线程，执行任务

线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

利用Callable、FutureTask接口实现。

优点：扩展性强，可以得到线程执行的结果。

代码演示

 package com.DarkHorse;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String>{

    private int n;
    public MyCallable(int n) {
        this.n=n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for(int i=1;i<n;i++) {
            sum+=i;
        }

        return "子线程执行的结果是："+sum;
    }

}
//
 package com.DarkHorse;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Main4 {

    public static void main(String[] args) {
        Callable<String> call=new MyCallable(100);
        FutureTask<String> f1=new FutureTask<>(call);
        Thread f2=new Thread(f1);
        f2.start();
        Callable<String> call2=new MyCallable(200);
        FutureTask<String> f4=new FutureTask<>(call2);
        Thread f3=new Thread(f4);
        f3.start();
        try {
            //如果f1没有执行完毕的话，这里的代码会等待，直到跑完才提取结果
            String rs1=f1.get();
            System.out.println("第一个结果是："+rs1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        try {
            String rs2=f4.get();
            System.out.println("第二个结果是："+rs2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}