多线程的实现

1.线程和进程的概述

1.1 什么是进程?

正在执行的程序，称为进程。 进程是系统分配资源的单元。 现在系统支持多进程的。

1.2 什么是线程?

线程，又称轻量级进程（Light Weight Process）。
线程是进程中的一条执行路径，也是CPU的基本调度单位。
若一个程序可同一时间执行多个线程，就是支持多线程的.
一个进程由一个或多个线程组成，彼此间完成不同的工作，
同时执行，称为多线程。

一个进程有多个或一个线程组成。比如: 360就是支持多线程的程序。  

进程与进程之间无法数据共享。

线程与线程之间可以共享数据。

2. 并发和并行的概述

并行：指两个或多个事件在同一时刻发生（同时发生 同时处理 执行者不是一个）。
并发：指两个或多个事件在同一个时间段内发生【交替的发生 执行者是一个】。

电脑（单核）在执行任务时是采用并发还是并行？
使用的是并发，因为电脑上只有一个CPU，但是电脑上却可以同时运行多个程序，这是一种假象,因为CPU的计算速度极快，10^-9每秒就会计算一次,而人能感觉到的时间流失是秒，所以电脑给我们一种感觉好像电脑上程序在同时执行。

3. 为什么使用多线程?

为了提高cpu的使用率。从而提高的程序的效率。

4. java如何实现多线程任务

默认java程序为单线程。只有一个main的主线程。

java实现多线程的方式有三种:

第一种: 继承Thread类

第二种: 实现Runnable接口

第三种: 实现Callable接口

4.1 继承Thread完成多线程

继承Thread
Thread就是一个线程类，里面定义所有和线程相关的功能，只有是这个类才能开启的任务，才能被CPU单独去执行。

Java中线程执行的时候是采用的并发。学习的过程中不要纠结于多个线程执行的结果，因为是随机在执行，抢占式的在使用CPU资源。

1.创建一个类并继承Thread
2.重写线程run方法---线程执行的的任务代码
3.创建线程并开启线程start()

public class MyThread extends Thread{

    //线程开启值要干的任务。
    @Override
    public void run() {
        //循环的目的就是让线程执行一段时间
        for (int i = 0; i < 20; i++) {
            System.out.println("线程=============>"+i);
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread t1=new MyThread();
        //2.开启线程start-底层-默认调用run方法
        t1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程------------------->"+i);
        }
    }
}

上面继承Thread类后，还能继承其他类吗？不能。 扩展性相对比较差。

4.2 实现Runnable接口

package org.example.demo02;

public class My implements Runnable{
    //线程启动后执行的任务代码块
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("线程任务代码----------------》"+i);
        }
    }
}
 

package org.example.demo02;

public class Test01 {
    public static void main(String[] args) {
        //1.创建任务对象
        My my=new My();
        //2.创建线程对象
        Thread t=new Thread(my); //把任务对象交于线程对象。
        t.start();//调用任务对象中的run方法
        for (int i = 0; i < 20; i++) {
            System.out.println("main线程："+i);
        }
    }
}
 

上面的方案 都无法获取任务执行后的结果。从jdk1.5后引入Callable完成任务 并可以有返回结果

4.3 实现Callable接口

package org.example.demo03;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    //线程开启后执行的任务代码。。
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 1; i <= 100; i++) {
            System.out.println("线程:"+i);
            sum+=i;
        }
        return sum;
    }
}

package org.example.demo03;

import org.example.demo02.My;

import java.util.concurrent.FutureTask;

public class Test01 {
    public static void main(String[] args) throws Exception {
        //1.创建MyCallable对象
        MyCallable my=new MyCallable();
        //2. 把上面的Callable对象封装到一个任务对象。FutureTask封装任务对象以及任务执行完的结果也封装到该类中
        FutureTask task=new FutureTask<>(my);
        //2.创建线程对象
        Thread t=new Thread(task);

        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main线程："+i);
        }

        System.out.println("线程执行任务的结果为:"+task.get());  //阻塞，等待线程执行完毕，获取线程执行结果
    }
}
 

4.4 三种创建多线程的使用场景

1、**继承Thread的方式**：适合于这个任务只想被一个线程的对象执行的情况

2、**实现Runnable接口方式**：适合于一个任务想被多个线程执行的情况. 卖票

3、**实现Callable接口方式**：也适合一个任务想被多个线程执行的情况，你还想得倒任务的执行结果