Java多线程编程

1. 进程

进程是指操作系统中正在运行的程序实例，它是系统资源分配的基本单位。每个进程都拥有独立的内存空间和系统资源，可以看作是程序的一次执行过程。

2. 线程

线程是进程中的执行单元，也被称为轻量级进程（Light Weight Process）。一个进程可以包含多个线程，这些线程共享进程的内存空间和资源，但拥有各自的栈空间和局部变量。线程是操作系统进行调度的基本单位，可以并发执行，实现多任务处理。

3. 多线程的优势

多线程编程可以带来以下优势：

• 提高系统资源利用率：多线程可以充分利用多核处理器的能力，提高CPU资源的利用率，加快程序的执行速度。
• 提高响应速度：通过多线程处理耗时操作，如网络请求、文件读写等IO操作，可以避免阻塞主线程，提升系统的响应速度和用户体验。
• 简化程序结构：将不同任务分配给不同线程处理，可以简化程序设计，提高代码的清晰度和可维护性。

4. Java中的多线程实现方式

Java提供了多种方式来实现多线程，主要包括继承Thread类、实现Runnable接口和实现Callable接口（带返回值）三种方式。

4.1 继承Thread类

继承Thread类是实现多线程的一种简单方式，适合于线程类的逻辑与业务较为紧密的情况。

java复制代码// 定义一个继承Thread类的线程
public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "~~~~~~~~~" + i);
        }
    }
}

// 在主程序中启动线程
public class TestThread {
    public static void main(String[] args) {
        MyThread my = new MyThread();
        my.start(); // 启动线程

        for (int i = 0; i < 20; i++) {
            System.out.println("main~~~~~~~~~~~~~" + i);
        }
    }
}

案例

public class SellTicket extends Thread {
    private int ticket=100;
    @Override
    public void run() {
       while (true){
           if(ticket>0){
               ticket--;
               System.out.println(Thread.currentThread().getName()+"卖了一张票,剩余:"+ticket+"张");
           }else{
               System.out.println(Thread.currentThread().getName()+"卖完了");
               break;
           }
       }
    }
}

public class TestTicket {
    public static void main(String[] args) {
        SellTicket task1=new SellTicket();
        SellTicket task2=new SellTicket();
        task1.setName("窗口1")
        task1.start();
        task2.setName("窗口2")
        task2.start();
    }
}

4.2 实现Runnable接口

实现Runnable接口是推荐的多线程实现方式，它将线程的任务逻辑与线程对象分离，提高了代码的灵活性和可复用性。

java复制代码// 定义一个实现Runnable接口的线程
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "~~~~~~~~~~~~~" + i);
        }
    }
}

// 在主程序中启动线程
public class TestRunnable {
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread t = new Thread(my, "线程名");
        t.start(); // 启动线程

        for (int i = 0; i < 20; i++) {
            System.out.println("main+++++++++++++++++++" + i);
        }
    }
}

案例

public class SellTicket implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(20);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                ticket--;
                System.out.println(Thread.currentThread().getName() + "卖了一张票；剩余:" + ticket + "张");
            } else {
                break;
            }
        }
    }
}

public class TestTicket {
    public static void main(String[] args) {
        SellTicket task=new SellTicket();

        Thread t1=new Thread(task,"窗口1");
        Thread t2=new Thread(task,"窗口2");
        Thread t3=new Thread(task,"窗口3");
        Thread t4=new Thread(task,"窗口4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

由结果发现: 会出现超卖和重卖现象。 这是因为多个线程共享一个资源，导致了线程安全隐患问题。后期解决线程安全问题。 后期我们可以使用锁解决。

继承Thread和实现Runnable的方式比较:使用实现Runnable比较好，因为Runnable是接口，扩展性更好

4.3 实现Callable接口

实现Callable接口允许线程执行有返回值的任务，并可以在任务完成后获取结果。

java复制代码// 实现Callable接口的线程，带有返回值
public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

// 在主程序中启动线程并获取返回值
public class TestCallable {
    public static void main(String[] args) throws Exception {
        MyCallable my = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(my);
        Thread t = new Thread(task);
        t.start();

        Integer result = task.get(); // 获取线程执行的结果
        System.out.println("1到100的和为：" + result);
    }
}

Java中的多线程编程是提高程序性能和响应能力的重要手段。选择合适的多线程实现方式可以根据需求和场景灵活应对，同时需要注意线程安全和资源竞争的问题，使用同步机制和锁等手段确保多线程程序的稳定和正确性。