Thread多线程1--创建多线程

一、前置知识

1.1 顺序、并发、串行、并行

1.1.1 顺序、并发

顺序和并发是指多个任务能否同时开始。

顺序：表示多个任务依次处理。上一个任务执行完毕后，当前任务才可以开始执行。（抢占CPU资源）

并发：表示多个任务同时处理。无论上一个任务是否执行完毕，当前任务都可以开始执行。

顺序执行

并行处理

1.1.2 串行、并发

百度…

1.2 单线程与多线程

1.2. 1 单线程

百度：单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            System.out.println("单线程："+i);
        }
    }
}


结果：单线程：1	单线程：2	单线程：3	单线程：4	单线程：5	单线程：6	单线程：7	单线程：8	单线程：9单线程：10....单线程：100

单线程程序在执行时，只有一个主体在执行，这个主体称为主线程。

1.2.2 多线程

百度:多线程是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算进因有硬件支持而能够在同一时间执行多于一个线程，从而提升整体处理性能。

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.print("Nice!");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t = new MyThread(); // 创建MyThread实例
        t.start(); // 启动线程
        for (int i = 0; i < 100; i++) {
            System.out.print("Good!");
        }
    }
}

结果：Good!Nice!Nice!Nice!....

注：start方法是Thread类中的方法，用于启动新线程。

1.3 线程的启动

1.3.1 利用Thread类的子类

// 创建输出指定字符串的线程类
public class PrintThread extends Thread {

    private String message;

    public PrintThread(String message) {
        this.message = message;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.print(message);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        new PrintThread("Good!").start(); // 启动线程
        new PrintThread("Nice!").start();
    }
}

主线程在Main方法中启动了两个线程，随后main方法便会终止，主线程也会跟着终止，但整个程序不会随之终止，因为启动的两个线程在字符串输出之前不会终止的。直到所有的线程都终止后，程序才会终止。

启动线程时调用的是start方法，而不是run方法

start方法主要执行：

1. 启动新线程
2. 调用run方法

利用Thread类创建线程：

1. 创建Thread类的子类
2. 创建子类的实例
3. 调用start方法

1.3.2 利用Runnable接口

public class Printer implements Runnable {

    private String message;

    public Printer(String message) {
        this.message = message;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.print(message);
        }
    }
}


public class Main {
    public static void main(String[] args) {
        new Thread(new Printer("Goode!")).start();
        new Thread(new Printer("Nice!")).start();
    }
}

利用Runnable创建线程：

1. 创建Runnable接口的实现类
2. 实现类传递给Thread的构造函数
3. 调用start方法

1.3.3 扩展：利用java.util.concurrent.ThreadFactory中的线程创建

public class Printer implements Runnable {

    private String message;

    public Printer(String message) {
        this.message = message;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.print(message);
        }
    }
}


import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
public class Main {
    public static void main(String[] args) {
        ThreadFactory factory = Executors.defaultThreadFactory();
        factory.newThread(new Printer("Nice1")).start();
        for (int i = 0; i < 100; i++) {
            System.out.print("Good!");
        }
    }
}

利用java.util.concurrent.ThreadFactory中的线程创建

1. 创建Runnable接口的实现类
2. 利用Executors.defaultThreadFactory()创建ThreadFactory对象
3. 将Runnable接口作为传入参数并通过隐藏在ThreadFactory内部的new创建Thread实例。
4. 调用start方法