一、线程

1. 什么是线程?

• 线程(Thread)是一个程序内部的一条执行流程。
• 程序中如果只有一条执行流程，那这个程序就是单线程的程序。

2. 多线程

• 多线程是指从软硬件上实现的多条执行流程的技术(多条线程由CPU负责调度执行)

3. 如何在程序中创建出多条线程?

Java是通过java.lang.Thread 类的对象来代表线程的。

3.1 线程创建方式一:继承Thread类

package com.test;

/**
 * 目标：掌握线程的创建方式一：集成Thread类
 */
public class LogBackTest {
    public static void main(String[] args) {
        //main方法由一条磨人的主线程负责执行
        //3.创建线程类的对象代表一个线程
        Thread myThread = new MyThread();
        //4.启动线程（自动执行run方法）
        myThread.start();//main线程 t线程
        for (int i = 0; i < 6; i++) {
            System.out.println("主线程"+i);
        }
    }
}

/**
 * 1.让子类继承Thread类
 */
class MyThread extends Thread{
    //2.必须重写Thread类的run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Mythread线程输出"+i);
        }
    }
}

多线程的注意事项
1、启动线程必须是调用star方法，不是调用run方法。
2、不要把主线程任务放在启动子线程之前。

---

3.2 线程创建方式二:实现Runnable接口

package com.test;

public class Thread2 {
    public static void main(String[] args) {
        //3. 创建任务对象
        Runnable myRun = new MyRun();
        //4. 把任务对象交给一个线程对象处理
        new Thread(myRun).start();
        for (int i = 0; i < 6; i++) {
            System.out.println("主线程"+i);
        }
    }
}

/**
 * 1. 定义一个人物类，实现Runnable接口
 */
class MyRun implements Runnable{
    //2. 重写run方法
    @Override
    public void run() {
        //线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程"+i);
        }
    }
}

线程创建方式二的匿名内部类写法

• 可以创建Runnable的匿名内部类对象。
• 再交给Thread线程对象。
• 再调用线程对象的start()启动线程。

package com.test;

public class ThreadTest1 {
    public static void main(String[] args) {
        Runnable myThread = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("子线程一" + i);
                }
            }
        };
        new Thread(myThread).start();
        
        //简化形式1：
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("子线程二" + i);
                }
            }
        }).start();
        
        //简化形式2：
        new Thread(()->{for (int i = 0; i < 100; i++) {
            System.out.println("子线程三" + i);
        }}).start();
        
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程"+i);
        }
    }
}

3.3 线程创建方式三:实现Callable接口

前两种线程创建方式都存在的一个问题

• 假如线程执行完毕后有一些数据需要返回，他们重写的run方法均不能直接返回结果。

怎么解决这个问题?
JDK5.0提供了Callable接口和FutureTask类来实现(多线程的第三种创建方式)

package com.test;

import javax.print.DocFlavor;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        //3、创建一个Callble对象
        Callable<String> myCallable = new MyCallable(100);
        //4、把Callbale的对象封装成一个FutureTask对象（任务对象）
        //未来任务对象的作用
        //是一个任务对象，实现了Runnable对象
        //可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果
        FutureTask<String> f1 = new FutureTask<>(myCallable);
        //5、把任务对象交给一个Thread对象
        new Thread(f1).start();
        //6、获取线程执行完毕后返回的结果
        //注意：如果执行到这儿，加入上面的线程还没有执行完毕，这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        String s = f1.get();
        System.out.println(s);
    }
}

/**
 * 1、让这个类实现Callable接口
 */
class MyCallable implements Callable{
    private int n;
    MyCallable(){}
    MyCallable(int n){
        this.n=n;
    }
    //2、重写call方法
    @Override
    public String call() throws Exception {
        //描述线程的任务，返回线程执行的结果
        int sum=0;
        for (int i = 0; i <= this.n; i++) {
            sum+=i;
        }
        return ""+sum;
    }
}

package com.test;

import sun.awt.windows.ThemeReader;

/**
 * 目标：掌握线程的创建方式一：集成Thread类
 */
public class LogBackTest {
    public static void main(String[] args) {
        //main方法由一条磨人的主线程负责执行
        //3.创建线程类的对象代表一个线程
        Thread t1 = new MyThread("我是卡卡西");
        MyThread t2 = new MyThread("我是小乔");
        //4.启动线程（自动执行run方法）
//        t1.setName("1号线程");
        t1.start();//main线程 t线程
        System.out.println(t1.getName());
//        t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName());

        //主线程对象的名字
        //哪个线程执行它，它就会得到哪个线程对象。
        Thread thread = Thread.currentThread();
        thread.setName("牛逼线程");
        System.out.println(thread.getName());
        for (int i = 0; i < 1; i++) {
            System.out.println("主线程的输出"+i);
        }
    }
}

/**
 * 1.让子类继承Thread类
 */
class MyThread extends Thread{
    MyThread(){}
    MyThread(String name){
        super(name);
    }
    //2.必须重写Thread类的run方法
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        for (int i = 0; i < 1; i++) {
            System.out.println(thread.getName()+"线程输出"+i);
        }
    }
}

package com.test;

public class ThreadTest4 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 6; i++) {
            System.out.println(i);
            if(i==3){
                //会让当前执行的线程暂停2s，再继续执行
                //项目经理让我加上这行代码，如果用户交钱了，我就注释掉！
                Thread.sleep(2000);
            }
        }

        //join方法作用：让当前调用这个方法的线程先执行完
        MyThread t1 = new MyThread();
        t1.start();
        t1.join();

        MyThread t2 = new MyThread();
        t2.start();
        t2.join();

        MyThread t3 = new MyThread();
        t3.start();
        t3.join();
    }
}

Thread其他方法的说明
Thread类还提供了诸如:yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会后续需要用到的时候再讲解。