Java-多线程

概念

进程：程序的基本执行实体
线程：操作系统能够进行运算调度的最小单位，被包含在进程之中，是进程的实际运作单位
并发：同一时刻，多个指令在单个CPU上交替执行。
并行：同一时刻，多个指令在多个CPU上同时执行。

多线程第一种实现方式——重写run方法

test代码：

public class test {
    public static void main(String[] args) {
        /*
        *  多线程的第一种启动方式：
        *       1.自己重新定义一个类继承Thread
        *       2.重写run方法
        *       3.创建子类对象并启动线程
        * */

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

线程类代码：MyThread

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(getName() + "hello");
        }
    }
}

多线程第二种实现方式——实现runable接口

test代码

public class test2 {
    public static void main(String[] args) {
        /*
        * 多线程第二种启动方式：
        *   1.自己定义一个类实现Runable接口
        *   2.重写里面的run方法
        *   3.创建自己的类方法
        *   4.创建一个Thread类的对象，开启线程
        * */

        // 创建MyRun对象
        MyRun mr = new MyRun();

        // 创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.setName("线程1");
        t2.setName("线程2");

        // 开启线程
        t1.start();
        t2.start();
    }
}

runable接口代码

package test614;

public class MyRun implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "hello");
        }
    }
}

多线程第二种实现方式——实现Callable接口和Future接口方式实现

test代码

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

public class test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 第3种实现方式：
        *   特点：可以获取到多线程的运行结果
        *   1.创建一个类MyCallable实现Callable接口
        *   2.重写call(有返回值，表示多线程的运行结果)
        *   3.创建MyCallable对象，表示多线程要执行的任务
        *   4.创建Future的对象（作用管理多线程运行的结果）
        *   5.创建Thread的对象并启动（表示线程）
        * */

        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<Integer>(mc);
        new Thread(ft).start();

        Integer result = ft.get();
        System.out.println(result);
    }
}

MyCallable代码

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

三种实现方式的对比