java当中的多线程

努力撸代码的小刑

已于 2022-03-09 12:15:42 修改

阅读量90

点赞数

分类专栏： java 文章标签： java 后端面试

于 2022-03-09 12:15:14 首次发布

本文链接：https://blog.csdn.net/weixin_40701758/article/details/123369330

版权

java 专栏收录该内容

72 篇文章 0 订阅

订阅专栏

并行（parallel）：指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个处理器上同时执行。多项工作一起执行，之后再汇总
并发（concurrency）：指两个或多个事件在同一个时间段内发生。指在同一个时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。同一时刻多个线程在访问同一个资源，多个线程对一个点

进程和线程的区别：

进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。
当然不同的线程也有自己独立的内存空间。对于方法区，堆中中的同一个对象的内存，线程之间是可以共享的，但是栈的局部变量永远是独立的。

根本区别：进程是操作系统资源分配的基本单位，
        而线程是处理器任务调度和执行的基本单位

资源开销：每个进程都有独立的代码和数据空间（程序上下文），
    程序之间的切换会有较大的开销；
    线程可以看做轻量级的进程，同一类线程共享代码和数据空间，
    每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

包含关系：如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

内存分配：同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的

影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

执行过程：每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行

线程状态：

线程的调度：

计算机通常只有一个cpu,在任意时刻只能执行一条机器指令,每个线程只有获得cpu的使用权才能执行指令.所谓多线程的并发运行,其实是从宏观上看,各个线程轮流获取cpu的使用权,分别执行各自的任务.在运行池中,会有多个处于就绪状态的线程在等待cpu, JAVA虚拟机的一项任务就是负责线程的调度.线程调度是指按照特定机制为多个线程分配CPU的使用.

1、分时的调度模式：是让所有的线程轮流获取cPU的使用权，并且平均分配每个线程占用的CPU的时间片

2、抢占式调度模式：JAVA虚拟机采用抢占式调度模式,是指优先让可运行池中优先级高的线程占用CPU,如果可运行池中的线程优先级相同,那就随机选择一个线程,使其占用CPU.处于运行状态的线程会一直运行,直至它不得不放弃CPU.

Java当中多线程的创建：

方式1：继承Thread类

/**
 * 多线程的几种方式
 * 方式一：
 *  继承Thread类，重写run()方法
 *  创建Thread子类的实例。创建子线程对象
 *  调用线程对象的start()方法启动线程
 *
 */
public class TestThread extends Thread{

    public TestThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"：正在执行！"+i);
        }
    }
}

方式二：

/**
 * 实现Runnable接口进行
 * 具体步骤如下：
 *  定义Runnable类的实现类，并重写接口的run（）方法，
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"i");
        }
    }
}

前面两种方式进行创建线程的时候可以使用匿名内部类进行创建

方式三：

/**
 * 创建Callable接口类的实例化的
    创建Callable接口实现类，并实现call方法，该call方法会成为线程执行体，
    0使用FutureTask类来进行包装Callable对象，该FutureTask封装到Callable的call方法的返回值
    使用FutureTask对象作为Thread的对象创建启动新的线程
    使用FutureTaskde的get方法返回执行结束后的返回值
 */
public class TestMyCallable {
    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask futureTask = new FutureTask<>(myCallable);
        Thread thread1 = new Thread(futureTask, "线程1");
        thread1.start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

/**
*
*/

public class MyCallable implements Callable {
    int i=0;
    @Override
    public Integer call() throws Exception {
        for (; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"i");
        }
        return i;
    }
}

方式四：使用线程池

/**
 * 线程和数据库连接这些资源也是非常的宝贵的，每次进行创建的，不需要进行毁灭。线程池是官方给了
 * API
 */
public class ThreadPoolTest {
    public static void main(String[] args) {
        //创建固定大小的线程池
        ExecutorService threadPool=Executors.newFixedThreadPool(10);
        while(true){
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    printInfo();
                }
            });
        }
    }
    public static void printInfo(){
        System.out.println("当前线程的名为"+Thread.currentThread().getName());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

方式五、使用定时器

/**
 * 实现多线程的方式四
 * 使用定时器：定时器是一种基于线程的工具类，
 * 可以使用定时来执行一个任务。例如，每10分钟抓取网上的数据等等
 */
public class CreateThreadDemo_Timer {
    private static final SimpleDateFormat format=new SimpleDateFormat("yyyy-mm--dd hh:mm:ss");
    public static void main(String[] args) {
        Timer timer = new Timer();
        try {
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("定时任务执行了。。");
                }
            },format.parse("2020-02-12 22:00:00"));
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

方式六、使用内部类的方式进行创建多线程的方式

这种方式是对Thread进行继承和实现Runnable接口来进行使用匿名内部类的方式进行创建。

三种方式之间区别

1、实现Runnable、Callable接口的方式创建多线程

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

2、使用Thread类创建多线程

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

线程类已经继承了Thread类，所以不能再继承其他父类。

3、Runnable和Callable的区别

Callable的重写方法是call()方法，Runnable重写的方法是run()