多线程编程

多线程概述：

进程：进程是处于运行过程中的程序，并且具有一定独立功能。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行。

多线程：一个程序中有多个线程在同时执行

一个程序运行后至少有一个进程，一个进程中可以包含多个线程，但至少有一个线程。

多线程运行原理：

CPU(中央处理器)做着高速的切换，对于CPU而言，它在某一时刻，只能执行一个程序，即只能运行一个进程，CPU不断地在这些进程之间切换。但因CPU的执行速度相对我们的感知实在太快，我们则感觉多个进程在同时执行。

实现多线程：

在java中实现多线程，有三种方式，继承Thread类，实现Runable接口，实现Callable接口

继承Thread类：

创建线程的步骤：

1. 定义一个类继承Thread 

2. 重写run方法

3. 创建子类对象，也就是创建线程对象

4. 调用start（）方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

package class26day;

public class TestThread extends Thread {//继承Thread
    public static void main(String[] args) {
        TestThread myTestThread =  new TestThread("分支");//new一个线程对象，构造函数给线程重命名
        TestThread myTestThread1 =  new TestThread("2号分支");//new一个线程对象，构造函数给线程重命名
        myTestThread.start();//开启线程
        myTestThread1.start();//开启线程
        currentThread().setName("主线程");
        for (int i = 0; i < 1000; i++) {
            System.out.printf("这是%s独立线程%s\n",currentThread().getName(),i);
        }
    }
    //重写Thread的run方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.printf("这是%s独立线程%d\n",currentThread().getName(),i);
        }
    }
    public TestThread() {}//无参构造函数
    public TestThread(String name) {
        super(name);//线程重命名构造函数
    }
}

Thread.currentThread()获取当前线程对象

Thread.currentThread().getName();获取当前线程对象的名称

线程对象调用run（）方法不开启线程。仅是对象调用方法。

线程对象调用start（）开启线程，并让jvm调用run方法在开启的线程中执行。

实现Runable接口：

创建线程的步骤：

1. 定义类实现Runnable接口。

2. 覆盖接口中的run方法。

3. 创建Thread类的对象。

4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

5. 调用Thread类的start方法开启线程。

package class26day;

public class TestRunnable implements Runnable {
    private String name;
    TestRunnable(String name){
        this.name = name;
    }
    //重写Thread的run方法
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.printf("这是%s的%s独立线程%d\n",name,Thread.currentThread().getName(),i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable子类的对象。注意它并不是线程对象
        TestRunnable T = new TestRunnable("TestRunnable");
        //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数
        Thread t1 = new Thread(T);
        t1.setName("线程1号");
        Thread t2 = new Thread(T);
        t2.setName("线程2号");
        //线程启动
        t1.start();
        t2.start();
        System.out.println(Thread.currentThread().getName()+"主线程");
    }
}

Thread和Runnable的区别

实现Runnable接口相比继承Thread类的优势：

1：实现Runnable接口避免了单继承的局限性

2：适合多个相同的程序代码的线程处理同一资源

3：继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。