多线程编程(1)

爱听歌的阿漓

已于 2023-05-28 01:24:08 修改

阅读量949

点赞数

分类专栏： JavaEE 文章标签： java jvm

于 2023-05-27 18:19:32 首次发布

本文链接：https://blog.csdn.net/m0_74007393/article/details/130896354

版权

JavaEE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本篇重点

了解进程和线程的区别和联系
使用Java，实现创建线程的五种写法

因为
进程，是比较“重量级”的，它不仅仅速度比较慢而且消耗资源多
创建一个进程，成本比较高
销毁一个进程，成本也比较高
调度一个进程，成本也挺高
所以，多进程编程，可以解决并发的问题，但是并不是一个高效的选择！！！
线程，则是更加轻量的进程（轻量级进程）

线程为什么比进程更加轻量？

线程与进程共用同一份进程的系统资源（1. 内存空间 2. 文件描述符表）（意味着，对于线程而言，系统资源是已经分配好了的，创建线程就省下了分配资源的开销）

线程
进程包含线程
一个进程里可以有一个线程，或者多个线程
每个线程都是独立的执行流.多个线程之间，也是并发执行的
操作系统，真正调度的，是在调度线程，而不是进程

$\color{red}{线程是操作系统调度运行的基本单位}$

多进程与多线程的吃鸡方式
多进程吃鸡方式
在这里插入图片描述
多线程吃鸡方式

优化吃鸡过程

再优化吃鸡过程的思考

如果一个线程出现了问题，那么会发生什么呢？？

进程与线程的区别

$\color{red}{进程和线程的区别：}$

  1. 进程包含线程
  2. 进程有自己独立的内存空间和文件描述符表.同一个进程中的多个线程之间，共享同一份地址空间和文件描述符表
  3. 进程是操作系统资源分配的基本单位，线程是操作系统调度执行的基本单位
  4. 进程之间具有独立性，一个进程挂了，不会影响到别的进程；同一个进程里的多线程之间，一个线程挂了，可能会把整个进程带走，影响到其他线程

使用Java进行多线程编程

方法一：继承 Thread, 重写 run

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello t");
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

想要结果更加明显一点可以加个for循环进行标记

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("hello t  -- "+i);
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        for (int i = 0; i < 30; i++) {
            System.out.println("hello main  -- "+i);
        }
    }
}

在这里插入图片描述

可以看出这里是随机进行打印的

使用sleep函数方便进行结果的查看

class MyThread extends Thread{
    @Override
    public void run() {
        while (true) {
            System.out.println("hello t");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

上述代码涉及到两个线程

main 方法所对应的线程（一个进程至少得有一个线程）也可以称为主线程
通过t.start创建的新线程

如何使用工具对进程进行查看呢？？

找到你的jdk --> bin --> jconsole.exe
在这里插入图片描述

方法二: 实现 Runnable, 重写 run

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello t");
            
        }
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();
        while (true) {
            System.out.println("hello main");
        }
    }
}

方法三: 继承 Thread, 重写 run, 使用匿名内部类

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello t");
                }
            }
        };
        t.start();
        while (true) {
            System.out.println("hello main");
        }
    }
}

方法四: 实现 Runnable, 重写 run, 使用匿名内部类

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello t");
                }
            }
        });
        t.start();
        while(true) {
            System.out.println("hello main");
        }
    }
}

方法五: 使用 lambda 表达式

创建线程最推荐的写法, 使用lambda表达式!! 最简单直观的写法

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true) {
                System.out.println("hello t");
            }
        },"我的线程");
        t.start();
        while (true) {
            System.out.println("hello main");
        }
    }
}