多线程的基本概念学习

基本概念

并行和并发

并行：在同一个时刻，有多个指令在单个CPU同时执行
并发：在同一个时刻，有多个指令在单个CPU交替执行

进程和线程

进程：正在运行的软件(就是操作系统中正在运行的一个应用程序)

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
动态性：进程的实质是程序的一次执行过程，进程是动态产生的，动态消亡的
并发性：任何进程都可以同其他进程一起并发执行（CPU在多个进程之间进行一个动态的切换）

线程：是进程中的单个顺序控制流，是一条执行路径（就是应用程序中做的事情）

单线程：一个线程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则成为多线程程序

多线程的实现方法

多线程的实现方案

方式1.继承Thread类

1> 定义一个类MyThread继承Thread类
2> 在MyThread类中从写run()方法
3> 创建MyThread类的对象
4> 启动线程

/**
 * @program: javase
 * @description: 继承Thread类实现多线程
 * @Author: 小白白
 * @create: 2019/12/06 - 12:54
 **/
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++){
            System.out.println("线程开启了" + i);
        }
    }
}

/**
 * @program: javase
 * @description: 继承Thread类的测试类
 * @Author: 小白白
 * @create: 2019/12/06 - 12:56
 **/
public class MyThread_text {
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread t1 = new MyThread();
        //创建一个线程对象
        MyThread t2 = new MyThread();
        //开启一个线程
        t1.start();
        //开启第二条线程
        t2.start();
    }
}

运行结果为两个线程交替运行，交替去争抢CPU的资源

思考：

为什么要重写run（）方法？
----------因为run()用来封装被线程执行的代码

run（）方法和start（）方法的区别？
---------run：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程
---------start：启动线程，然后由JVM调用此线程的run()方法

start方法的底层源码。-----------native表示调取本地方法

方式2.实现Runnable接口

1.定义一个类MyRunnable实现Runnable接口
2.在MyRunnable类中重写run()方法
3.创建Runnable类的对象
4.创建Thread类的对象，把MyRunnbable独享作为构造方法的参数
5.启动线程
package com.zxh.Thread.Demo;

/**
 * @program: javase
 * @description: 实现Runnable接口
 * @Author: 小白白
 * @create: 2019/12/06 - 14:01
 **/
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程启动后执行的代码
        for (int i = 0; i < 100;i++){
            System.out.println("第二种方法实现多线程" + i);
        }
    }
}

/**
 * @program: javase
 * @description: 实现Runnable接口的测试类
 * @Author: 小白白
 * @create: 2019/12/06 - 14:03
 **/
public class MyRunnable_test {
    public static void main(String[] args) {
        //创建了一个参数的对象
        MyRunnable myRunnableTest = new MyRunnable();
        //创建了一个线程对象，并把参数传递给这个线程
        //在线程启动之后，执行的就是参数里面的run方法
        Thread t= new Thread(myRunnableTest);
        //开启线程
        t.start();
    }
}

方式3：通过Callable接口进行实现

1.定义一个类MyCallable实现Callable接口
2.在MyCallable中重写call（）方法
3.创建MyCallable类的对象
4.创建Future的是实现类FutureTask对象，把MyCallable对象作为构造方法的参数
5.创建Thread类的对象，把FutureTask对象作为构造方法的参数
6.启动线程

/**
 * @program: javase
 * @description: 实现Callable接口
 * @Author: 小白白
 * @create: 2019/12/06 - 18:59
 **/
public class MyCallable implements Callable<Object> {

    //在MyCallable中重写call（）方法
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值表示线程运行完毕之后的结果
        return "答应";
    }
}

import java.util.concurrent.*;

/**
 * @program: javase
 * @description: 实现Callable接口的测试类
 * @Author: 小白白
 * @create: 2019/12/06 - 19:03
 **/
public class MyCallable_text {
    public static void main(String[] args) {
        //创建MyCallable类的对象
        MyCallable mc = new MyCallable();
        //创建Future的是实现类FutureTask对象，把MyCallable对象作为构造方法的参数
        FutureTask<Object> ft = new FutureTask<Object>(mc);
        //创建Thread类的对象，把FutureTask对象作为构造方法的参数
        Thread t1 = new Thread(ft);
        //启动线程
        t1.start();
    }
}

三种方式的对比：

---

分析实现方法

Thread实现方法：

Thread.currentThread().getName()实现方法（init的底层）：

获取线程名字是getName()方法，设置线程名字是setName()方法，直接设置就可以