Java 多线程基础

Java 多线程基础

在学习多线程之前希望大家了解

进程与线程的区别

1.进程是资源分配的基本单位，而线程是CPU调度的基本单位。

2.进程拥有独立的地址空间，这保证了进程之间的数据隔离和安全性。当一个进程崩溃时，其他进程不会受到影响。而线程只是进程中的一个执行路径，没有独立的地址空间，所有线程共享进程的地址空间和资源。因此，一个线程的错误可能导致整个进程的崩溃。

3.每个进程都拥有独立的内存空间，需要大量数据表来维护每个进程分配和管理这些资源，线程不需要独立开辟内存空间，这意味着创建、销毁或切换线程的开销较小。

OOM（Out of Memory）是指计算机运行时由于内存不足而无法继续执行程序的现象。当进程申请的内存超过系统可用的内存时，就会发生OOM。在多线程环境中，如果使用了无界队列并且任务处理速度跟不上任务生成速度，队列会持续增长并占用大量内存，最终可能导致OOM。

线程

线程是一个程序内部的一条执行流程

多线程

多线程是指从软硬件上实现的多条执行流程的技术（多线程由cpu复制调度执行），同时执行若干线程

 多线程的实现

创建多线程

方法一：继承Thread类

java是通过java.lang.Thread类的对象来代表线程

public class MyThread extends Thread{
    // 1.继承线程
    // 2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("这是子线程"+i);
        }
    }

    public static void main(String[] args) {
        // 3.main主线程，创建多线程对象
        // 4.创建多线程对象
        Thread  myThread = new MyThread();
        // 5.调用start开启线程
        myThread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("这是主线程"+i);
        }
    }
}

方式优缺点

子类继承Thread类具备多线程能力

启动线程：子类对象.start

不建议使用

优点：编码简单

缺点：只能单继承，不利用功能扩展

方法二：实现Raunable接口

与Thread的区别在于start方法需要new Thread继承类

public class TestRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("这是子线程"+i);
        }
    }

    public static void main(String[] args) {
        Runnable runnable = new TestRunnable();
        new Thread(runnable).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("这是主线程"+i);
        }
    }
}

方式优缺点（并发）多个线程操作同一个对象

public class TestRunnable2 implements Runnable{
    private int num = 10;
//重写run方法
    @Override
    public void run() {
        while (true){
            if (num <= 0 ){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了第"+ num-- +"张票");
        }
    }

    public static void main(String[] args) {
      //new4个线程对象
      Runnable  testRunnable = new TestRunnable2();
      new Thread(testRunnable,"小明").start();
      new Thread(testRunnable,"小画").start();
      new Thread(testRunnable,"小花").start();

    }
}

避免单继承局限性，灵活方便，方便一个对象被多个线程调用

例子

public class TestRunnable2 implements Runnable{
    private int num = 10;

    @Override
    public void run() {
        while (true){
            if (num <= 0 ){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"抢到了第"+ num-- +"张票");
        }
    }

    public static void main(String[] args) {
        Runnable  testRunnable = new TestRunnable2();
        new Thread(testRunnable,"小明").start();
        new Thread(testRunnable,"小画").start();
        new Thread(testRunnable,"小花").start();

    }
}

优点：多继承，扩展性强

内部类优化Runnable代码

Runnable bb = new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i <= 5 ; i++) {
            System.out.println("子线程"+i);
        }
    }
};
new Thread(bb).start();

new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.println("子线程3"+i);
        }
    }
}).start();

lambda表达式优化

（不知道这个表达式的看我其他文章）

new Thread(() -> {
    for (int i = 0; i <= 5; i++) {
        System.out.println("子线程4"+i);
    }

}).start();

方法三：实现callable接口（较难基础先了解一下就行）

执行完毕返回结果

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        // 这里是你要执行的任务
        // 假设我们只是返回一个简单的字符串
        return "Hello from Callable!";
    }

    public static void main(String[] args) throws Exception {
        // 创建一个ExecutorService
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // 提交Callable任务给ExecutorService
        Future<String> future = executorService.submit(new MyCallable());

        // 获取Callable任务的结果
        String result = future.get();

        // 输出结果
        System.out.println(result);

        // 关闭ExecutorService
        executorService.shutdown();
    }
}