【Java多线程之线程基础 1 】

于 2022-08-09 15:14:57 发布
阅读量114 收藏
点赞数 2
分类专栏： JAVA技术分享 文章标签： java 服务器 jvm 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58988988/article/details/126248103
版权

文章目录

线程相关的概念

计算机程序运行的过程

计算机分为几种设备：

  1. 输入设备：键盘、鼠标
  2. 输出设备：显示器、耳机
  3. 存储设备：磁盘、内存、u盘
  4. 运算设备：cpu

在这里插入图片描述

进程和线程

进程：运行后的程序，是操作系统分配系统资源（内存空间、CPU）的最小单位

线程：每个进程由一个或多个线程组成，线程是CPU进行分配和调度的最小单位（分配时间片）

对比进程和线程：

​ 1. 内存方面：

​ 进程需要的资源更多（堆、方法区、本地方法区），线程更轻量级（栈、程序计数器）

​ 线程共享所在进程的内存空间（堆、方法区、本地方法区）

  1. 创建和销毁以及上下文切换：

    进程需要更多时间和资源，线程更快

    1. 相互通信方面：

    进程之间的通信比较麻烦（RPC、网络），线程之间通信更容易（通过进程共享的内存空间）

并行和并发

一个CPU内核一个时间段只能运行一个线程的指令，因为CPU执行的速度特别快所以感觉多个程序同时运行
并发：一个CPU在多个线程间来回切换执行，不是真正同时执行

并行：多个CPU同时执行多个线程，是真正同时执行

同步和异步

程序指令执行过程分为：

同步：多个程序指令排队执行

​ 执行有序，数据更加安全

异步：多个程序指令同时执行

​ 效率更高，执行无序，数据可能会有问题

为什么要使用多线程

线程是程序指令的单独的执行路径，多线程同时执行，大大提高了程序的执行效率

应用场景：

  1. 多线程下载
  2. 游戏（图形绘制、游戏控制、网络通信。。）
  3. 互联网应用（服务器为每个用户单独开线程，相互不影响）

线程的实现

java实现的三种方法：

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口

继承Thread类

1） 定义类继承Thread类

2） 重写run方法

3） 创建线程对象，调用start方法

/**
 * 自定义线程
 */
public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        MyThread thread1 = new MyThread();
        //启动线程
        thread1.start();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}

面试问题

1） 执行run和start有什么区别？

​ 调用run是在主线程中同步执行的，调用start后才会启动新线程去执行

2） 调用两次start会怎么样？

​ 会抛出异常IllegalThreadStateException，线程是一次性的，不允许执行两次

3） 多线程的执行是什么顺序？

​ 上下文切换

​ 多线程的执行是抢占式的，线程会去抢占CPU，抢到后执行自己的指令，执行过程中CPU可能被其它线程抢占，其它线程执行

​ 上下文切换回原来线程时，如何执行从哪里开始执行？

​ 每个线程有自己的程序计数器，保存当前线程执行的行数，切换回来后继续执行下面的行代码

实现Runnable接口

1） 定义类实现Runnable接口

2） 实现run方法

3） 创建Thread对象，传入Runnable对象，调用start

/**
 * 自定线程 Runnable方式
 */
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable对象 创建Thread对象
        Thread thread1 = new Thread(new MyRunnable());
        //启动线程
        thread1.start();
        //匿名内部类
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+i);
                }
            }
        });
        thread2.start();
        //lambda表达式
        Thread thread3 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"--->"+i);
            }
        });
        thread3.start();
    }
}

面试问题

1） 继承Thread类和实现Runnable两种方式的区别

​ 1> Java是单继承的，继承Thread类就不能继承其它类，实现接口没有此限制

​ 2> 继承Thread不强制要求重写run，实现Runnable强制要求

​ 3> Runnable可以使用Lambda表达式，语法简介

​ 推荐使用Runnable方式

​

实现Callable接口

前面两种方式都实现的run方法没有返回值，如果需要进行运算后返回值，就需要使用Callable接口

1） 实现Callable接口的call方法

2） 创建FutureTask对象传入Callable实现对象

3） 创建Thread线程传入FutureTask对象

4） 启动线程

5） 通过FutureTask的get方法获得返回值

/**
 * 带返回值的线程对象
 */
public class MyCallable implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        long sum = 0;
        for(int i = 0;i < 10000000;i++){
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        //创建FutureTask对象，传入Callable对象
        FutureTask<Long> futureTask = new FutureTask<>(new MyCallable());
        //创建Thread对象
        Thread thread = new Thread(futureTask);
        //启动线程
        thread.start();
        //获得返回值
        try {
            Long value = futureTask.get();
            System.out.println("运算结果是：" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程的生命周期

线程的生命周期（状态）分为：

  1. 新建
  2. 就绪/准备
  3. 运行
  4. 阻塞
  5. 死亡

在这里插入图片描述

线程的常用方法

常用方法：

  • start() 启动线程
  • stop() 停止线程
  • setName(String) 设置名字
  • getName() 获得名字
  • sleep(long) 睡眠
  • suspend() 挂起线程
  • resume() 恢复线程
  • yield() 放弃执行
  • join() 合并线程
  • setPriority(int) 设置线程优先级
  • setDaemon(boolean) 设置后台线程

停止线程

  • stop() 调用stop会停止线程，不会释放锁，可能导致死锁，禁用stop
  • 等待run执行完
  • 在run执行代码中加入条件，中途停止执行

线程的睡眠

Thread类的静态方法 sleep(毫秒数)

Thread.sleep(毫秒) 阻塞住当前线程，当时间结束后线程自动唤醒

面试题：wait和sleep的区别

  1. 调用对象不同： wait是锁对象调用，sleep是当前线程调用
  2. 唤醒机制不同： 线程进入wait后，要通过锁对象notify/notifyAll唤醒，sleep当时间结束自动唤醒
  3. 锁释放不同：线程进入wait后，会自动释放锁，线程sleep不会释放锁

线程的优先级

线程有优先级从低到高分为1~10，默认是5

线程优先级越高抢到CPU的几率越高

可以给执行更重要任务的线程设置更高的优先级

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        });
        //设置优先级
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
        thread2.start();

后台线程

后台线程也叫守护线程（精灵线程），后台线程的任务是为其它线程提供服务，当其它线程都死亡后，后台线程会自动死亡

setDaemon(true) 设置后台线程

应用场景：gc线程（垃圾收集器）就是典型的后台线程

public class DaemonDemo {

    public static void main(String[] args) {
        Thread daemon = new Thread(() -> {
            for (int i = 0; ; i++) {
                System.out.println(Thread.currentThread().getName()+"--->"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        daemon.setName("守护线程");
        //设置守护线程
        daemon.setDaemon(true);
        daemon.start();
        //被守护线程
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10; j++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+j);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

合并线程

线程的执行是抢占式的，在线程内部可以合并其它线程，让其它线程的执行代码在当前线程前面执行，然后执行自己的指令

public class JoinDemo {

    static Thread thread1 = null,thread2 =null ;

    public static void main(String[] args) {
        thread1 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"执行了"+i);
                try {
//                    if(i == 5){
//                        thread2.join();
//                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread2 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"执行了"+i);
                try {
                    if(i == 5){
                        //合并线程1
                        thread1.join();
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread2.setName("帅小伙");
        thread1.setName("老太太");
        thread1.start();
        thread2.start();
    }
}
清风ikl
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值