多线程的三种创建方式

基本概念

程序：指令和数据的有序集合，本身没有任何运行的含义，是一个静态的概念，。

进程：在操作系统中运行的程序。程序执行的过程。动态概念

线程：CPU调度和执行的单位，一个进程可包含若干个线程。

多线程：真正的多线程有所个CPU（多核），如服务器。如果时模拟出来的多线程，即再一个cpu的情况下，再同一时间，cpu只能执行一个代码，因为切换很快，所以就有同时执行的错觉。

总结：

• 线程是独立执行的路径。
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。
• main()称之为主程序，为系统的入口，用于执行整个程序。
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器与操作系统紧密相关，先后顺序不能人为干预。
• 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
• 线程会带额外的开销，如cpu调度时间，并发控制开销。
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程三种创建方式

1，继承Thread

​ 1)自定义一个类，并继承Thread类

​ 2）重写run()方法

​ 3）调用start()方法开启线程

//方式一：继承Thread类，重写run()方法，调用start方法开启子线程
//线程开启不一定立即执行，由cpu调度执行
public class ThreadDemo1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("这是子线程在执行---"+(i+1));
        }
    }

    public static void main(String[] args) {
        //main,主线程

        //创建一个线程对象
        ThreadDemo1 threadDemo1=new ThreadDemo1();
        //调用start()方法开启线程
        threadDemo1.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("这是main在执行========="+(i+1));
        }
    }
}

2，实现Runnable接口

​ 1）自定义类实现Runnable接口

​ 2）重写run()方法

​ 3）在main方法中创建实现Runnable接口的类的对象

​ 4）创建线程对象，通过线程对象开开启子线程调用start()方法

//方式二 实现Runnable接口
public class ThreadDemo2 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("这是子线程在执行---"+(i+1));
        }
    }

    public static void main(String[] args) {

        //创建一个Runnable接口的实现类对象
        Runnable threadDemo2 = new ThreadDemo2();
        //创建线程对象，通过线程对象开启线程，(代理)
        Thread tdemo=new Thread(threadDemo2);
        //调用start()方法开启线程
        tdemo.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("这是main在执行========="+(i+1));
        }
    }
}

3，实现Callable接口

1，实现Callable接口，需要返回值类型
2，重写call方法，需要抛出异常
3，创建目标对象 DemoCallable demoCallable1 = new DemoCallable(“小明”);
4，创建执行服务： ExecutorService ser= Executors.newFixedThreadPool(3);
5提交执行结果 Future r1=ser.submit(demoCallable1);
6.获取结果 boolean rs1=r1.get();
7关闭服务 ser.shutdownNow()

import java.util.concurrent.*;

//实现callable接口
//好处
//可以定义返回值，可以抛出异常
public class DemoCallable implements Callable<Boolean> {

    private String name;//名
public DemoCallable(String name){
    this.name=name;
}

    @Override
    public Boolean call() throws Exception {
        System.out.println(name+"开始活动");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
//      创建目标对象
        DemoCallable demoCallable1 = new DemoCallable("小明");
        DemoCallable demoCallable2 = new DemoCallable("小红");
        DemoCallable demoCallable3 = new DemoCallable("小军");

//        创建执行服务：
        ExecutorService ser= Executors.newFixedThreadPool(3);

//         提交执行
        Future<Boolean> r1=ser.submit(demoCallable1);
        Future<Boolean> r2=ser.submit(demoCallable2);
        Future<Boolean> r3=ser.submit(demoCallable3);
//         获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();
        System.out.println(rs1+"\t"+rs2+"\t"+rs3);
//        关闭服务
        ser.shutdownNow();
    }
}