Java多线程基础学习笔记

最新推荐文章于 2022-04-06 15:45:03 发布

陈多鱼

最新推荐文章于 2022-04-06 15:45:03 发布

阅读量991

点赞数

分类专栏： JVM 文章标签：多线程 javase

本文链接：https://blog.csdn.net/qq_42338771/article/details/108354004

版权

JVM 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

引言

  最近在学习jdk源码中的Object类时，看见wait(),notify()相关的内容时一头雾水，果然非科班出身虽然会做些应用，但是基础还是比较薄弱。
简单学习了一些多线程相关的基础知识，在此简单记录一下。

问题一：什么是线程，进程，以及协程

进程: 本质上是一个独立执行的程序，进程是操作系统进行资源分配和调度的基本概念，操作系统进行资源分配和调度的一个独立单位

线程:是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程中可以并发多个线程，每条线程执行不同的任务，切换受系统控制。

协程: 又称为微线程，是一种用户态的轻量级线程，协程不像线程和进程需要进行系统内核上的上下文切换，协程的上下文切换是由用户自己决定的，有自己的上下文，所以说是轻量级的线程，也称之为用户级别的线程就叫协程，一个线程可以多个协程,线程进程都是同步机制，而协程则是异步 
Java的原生语法中并没有实现协程,目前python、Lua和GO等语言支持

关系：一个进程可以有多个线程，它允许计算机同时运行两个或多个程序。线程是进程的最小执行单位，CPU的调度切换的是进程和线程，进程和线程多了之后调度会消耗大量的CPU，CPU上真正运行的是线程，线程可以对应多个协程

协程的优缺点：
优点：
    非常快速的上下文切换，不用系统内核的上下文切换，减小开销
    单线程即可实现高并发，单核CPU可以支持上万的协程
    由于只有一个线程，也不存在同时写变量的冲突，在协程中控制共享资源不需要加锁
缺点：
    协程无法利用多核资源，本质也是个单线程
    协程需要和进程配合才能运行在多CPU上
    目前java没成熟的第三方库，存在风险
    调试debug存在难度，不利于发现问题

个人理解：因为同步操作过程中，若某一过程需执行太长时间，导致整个任务执行过慢，因此引入多线程，进行线程的切换来实现异步任务，从而提高程序的执行效率。

问题二：JAVA是如何实现多线程操作的

方式一：继承Thread

继承Thread，重写里面run方法，创建实例，执行start
优点：代码编写最简单直接操作
缺点：没返回值，继承一个类后，没法继承其他的类，拓展性差

public class ThreadDemo1 extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread实现多线程，名称："+Thread.currentThread().getName());
    }
}



public static void main(String[] args) {

      ThreadDemo1 threadDemo1 = new ThreadDemo1();
      threadDemo1.setName("demo1");
      threadDemo1.start();
      System.out.println("主线程名称："+Thread.currentThread().getName());

}

方式二：实现Runnable接口

自定义类实现Runnable，实现里面run方法，创建Thread类，使用Runnable接口的实现对象作为参数传递给Thread对象，调用Strat方法

优点：线程类可以实现多个几接口，可以再继承一个类
缺点：没返回值，不能直接启动，需要通过构造一个Thread实例传递进去启动


public class ThreadDemo2 implements Runnable {

    @Override
    public void run() {
        System.out.println("通过Runnable实现多线程，名称："+Thread.currentThread().getName());
    }
}



public static void main(String[] args) {
        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        Thread thread = new Thread(threadDemo2);
        thread.setName("demo2");
        thread.start();
        System.out.println("主线程名称："+Thread.currentThread().getName());
}




JDK8之后采用lambda表达式
public static void main(String[] args) {
    Thread thread = new Thread(()->{
                System.out.println("通过Runnable实现多线程，名称："+Thread.currentThread().getName());
            });
    thread.setName("demo2");
    thread.start();
    System.out.println("主线程名称："+Thread.currentThread().getName());
}

方式三：通过Callable和FutureTask方式

创建callable接口的实现类，并实现call方法，结合FutureTask类包装Callable对象，实现多线程
优点：有返回值，拓展性也高
缺点：jdk5以后才支持，需要重写call方法，结合多个类比如FutureTask和Thread类


public class MyTask implements Callable<Object> {
    @Override
    public Object call() throws Exception {

        System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());

        return "这是返回值";
    }
}

 public static void main(String[] args) {


        FutureTask<Object> futureTask = new FutureTask<>(()->{
            System.out.println("通过Callable实现多线程，名称："+Thread.currentThread().getName());
            return "这是返回值";
        });


//        MyTask myTask = new MyTask();
//        FutureTask<Object> futureTask = new FutureTask<>(myTask);

        //FutureTask继承了Runnable，可以放在Thread中启动执行
        Thread thread = new Thread(futureTask);
        thread.setName("demo3");
        thread.start();
        System.out.println("主线程名称:"+Thread.currentThread().getName());

       try {

            System.out.println(futureTask.get());

        } catch (InterruptedException e) {
            //阻塞等待中被中断，则抛出
            e.printStackTrace();
        } catch (ExecutionException e) {

            //执行过程发送异常被抛出
            e.printStackTrace();
        }


    }

方式四：通过线程池创建线程

自定义Runnable接口，实现run方法，创建线程池，调用执行方法并传入对象
优点：安全高性能，复用线程
缺点: jdk5后才支持，需要结合Runnable进行使用


public class ThreadDemo4 implements Runnable {

    @Override
    public void run() {
        System.out.println("通过线程池+runnable实现多线程，名称："+Thread.currentThread().getName());
    }
}


public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for(int i=0;i<10;i++){
            executorService.execute(new ThreadDemo4());
        }


        System.out.println("主线程名称:"+Thread.currentThread().getName());

        //关闭线程池
        executorService.shutdown();
}

常用的是方式几呢？

  这个问题不难回答，因为JAVA只支持单继承，因此如果使用继承Thread方式的话，不方便业务的拓展，因此往往实现Runnable接口
且为了使进程的操作更加快捷，往往使用池化操作，因此常用的应该是方式二和四

问题三：JAVA的线程有几种状态

JDK的线程状态分6种，JVM里面9种，我们一般说JDK的线程状态

常见的5种状态

创建(NEW): 生成线程对象，但是并没有调用该对象start(), new Thread()

就绪(Runnable)：当调用线程对象的start()方法，线程就进入就绪状态，但是此刻线程调度还没把该线程设置为当前线程，就是没获得CPU使用权。   如果线程运行后，从等待或者睡眠中回来之后，也会进入就绪状态
    注意:有些文档把就绪和运行两种状态统一称为 “运行中”

运行(Running)
    程序将处于就绪状态的线程设置为当前线程，即获得CPU使用权，这个时候线程进入运行状态，开始运行run里面的逻辑

阻塞(Blocked)
    等待阻塞：进入该状态的线程需要等待其他线程作出一定动作(通知或中断)，这种状态的话CPU不会分配过来，他们需要被唤醒，可能也会无限等待下去。比如调用wait(状态就会变成WAITING状态)，也可能通过调用sleep(状态就会变成TIMED_WAITING), join或者发出IO请求，阻塞结束后线程重新进入就绪状态
    
    同步阻塞：线程在获取synchronized同步锁失败，即锁被其他线程占用，它就会进入同步阻塞状态
    
    备注：相关资料会用细分下面的状态
        等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
        超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回
    

死亡(TERMINATED):一个线程run方法执行结束，该线程就死亡了，不能进入就绪状态

常用的线程状态转换API

sleep
    属于线程Thread的方法
    让线程暂缓执行，等待预计时间之后再恢复
    交出CPU使用权，不会释放锁
    进入阻塞状态TIME_WAITGING，睡眠结束变为就绪Runnable
    
yield
    属于线程Thread的方法
    t1/t2/t3
    暂停当前线程的对象，去执行其他线程
    交出CPU使用权，不会释放锁，和sleep类似
    作用：让相同优先级的线程轮流执行，但是不保证一定轮流
    注意：不会让线程进入阻塞状态，直接变为就绪Runnable，只需要重新获得CPU使用权
    
    
join  
    属于线程Thread的方法
    在主线程上运行调用该方法，会让主线程休眠，不会释放已经持有的对象锁
    让调用join方法的线程先执行完毕，在执行其他线程
    类似让救护车警车优先通过
    
wait
    属于Object的方法
    当前线程调用对象的wait方法，会释放锁，进入线程的等待队列
    需要依靠notify或者notifyAll唤醒，或者wait(timeout)时间自动唤醒
    
notify
    属于Object的方法
    唤醒在对象监视器上等待的单个线程，选择是任意的
    
notifyAll
    属于Object的方法
    唤醒在对象监视器上等待的全部线程

线程状态转换图：