多线程入门

一、线程概念

程序：静态的：指的是代码，没有运行的

动态：正在运行的程序

进程：正在独立执行的程序叫做进程。QQ、迅雷、百度网盘

线程：在进程中执行的一个任务叫做线程。

QQ：聊天、视频、传输文件

百度网盘：下载多个文件

在操作系统中，每个运行的程序都是一个进程

在一个进程中开辟的多个执行单元同时运行，来完成不同的多个任务

每一个执行单元都可以看作程序执行的线索，这个线索为线程。

每一个线程都会至少存在一个线程，Java程序启动时候，就会产生一个进程，这个进程会默认创建一个线程，就是main线程

一个进程开辟多个线程，每个线程是按照cpu分配的时间片执行

cpu选择一个可以执行的线程，把这个线程调度的cpu进行运行

运行完毕后，切换到下一个要运行的线程。刚才运行线程处于挂起状态

如果是多个cpu的服务器，可以同时运行多个线程，真正做到线程并发执行

二、多线程的好处

1、提高程序运行效率

2、充分利用cpu资源

3、可以并发的执行

三、创建线程

1）、继承Thread类

Thread类用来实现多线程

创建第一个线程：

//定义一个继承Thread线程类的子类
public class Test01 extends Thread{
    //创建构造方法
    //参数，线程名字
    public Test01(String name) {
        super(name);
    }
//重写Thread类的run方法，里面定义了线程Test01运行的代码，所有该线程完成的功能代码，都写在这个run方法中
    @Override
    public void run() {
        int i =0;
        while (i++<5){
            System.out.println(Thread.currentThread().getName()+"的run方法在运行");
        }
    }
​
    public static void main(String[] args) {
        //创建实例
        Test01 test01 = new Test01("test01");
        //启动线程:调用start方法
        test01.start();//让当前线程处于就绪状态，随时可以运行状态，但是具体看cpu
    }
}

2）、实现Runnable接口

继承Thread类，Java是单继承。

创建实现Runnable接口的线程

//实现Runnable接口
public class Test02 implements Runnable{
​
    //重写run方法
    @Override
    public void run() {
        int i =0;
        while (i++<5){
            System.out.println(Thread.currentThread().getName()+"的run方法在运行");
        }
    }
​
    public static void main(String[] args) {
        //创建Runnable接口实现类的实例对象，实例化线程类
        Test02 test02 = new Test02();
​
        //创建Thread类Thread(Runnable target,String name)构造方法创建线程对象
        Thread thread = new Thread(test02,"thread");
        //调用线程对象start()方法启动线程
        thread.start();
        //创建Thread1线程对象
        Thread thread1 = new Thread(test02,"thread1");
        thread1.start();
​
    }
}

3）、实现Callable接口

因为继承Thread类和实现Runnable接口，重写run方法，run方法不提供返回值

JDK1.5开始提供

A、创建Callable接口的实现类，同时重写Callable接口的call方法

B、创建Callable接口的实现类对象 new Callable接口的实现类

C、通过FutureTask线程结果处理类的有参构造方法来封装Callable接口类实现对象

D、使用参数为FutureTask类对象的Thread有参构造方法创建Thread线程的实例

E、调用线程实例的start方法启动线程

创建线程

//实现Callable接口
public class Test03 implements Callable<Object> {
    //重写Callable的call方法
    @Override
    public Object call() throws Exception {
        int i =0;
        while (i++<5){
            System.out.println(Thread.currentThread().getName()+"的run方法在运行");
        }
        return i;
    }
​
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable接口实现对象
        Test03 test03 = new Test03();
        //使用FutureTask封装Callable接口，用来处理返回值
        FutureTask<Object> future = new FutureTask<Object>(test03);
​
        //Thread thread = new Thread(future,"test03");
        //FutureTask是Runnable接口的一个子接口构造方法创建对象
        Thread thread = new Thread(future,"test03");
        thread.start();
        Object o = future.get();
        System.out.println(o);
    }
}