实现多线程，使两个类同时运行

基础概念

多线程是指在一个程序中同时运行多个线程，每个线程执行不同的任务。多线程可以提高程序的并发性和响应性，充分利用CPU资源。

优势

提高程序性能：通过多线程，可以同时执行多个任务，减少等待时间。
提高资源利用率：多线程可以充分利用多核CPU的优势，提高CPU的利用率。
增强程序响应性：对于需要长时间运行的计算密集型任务，多线程可以使程序在执行这些任务的同时，仍然能够响应用户的输入。

类型

用户级线程：由用户程序通过线程库实现，操作系统内核不感知这些线程。
内核级线程：由操作系统内核直接管理和调度，每个线程都有独立的内核栈。

应用场景

并发处理：如服务器处理多个客户端请求。
I/O密集型任务：如文件读写、网络通信等。
计算密集型任务：如科学计算、图像处理等。

实现多线程的示例代码（Java）

以下是一个简单的Java示例，展示如何实现两个类同时运行：

public class MultiThreadExample {
    public static void main(String[] args) {
        // 创建两个线程
        Thread thread1 = new Thread(new Task1());
        Thread thread2 = new Thread(new Task2());

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

class Task1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Task1 - " + i);
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Task2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Task2 - " + i);
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可能遇到的问题及解决方法

线程安全问题：多个线程同时访问和修改共享资源时，可能会导致数据不一致。解决方法是使用同步机制，如synchronized关键字或Lock接口。

public class SharedResource {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

死锁问题：两个或多个线程互相等待对方释放资源，导致程序无法继续执行。解决方法是设计合理的锁顺序，避免循环等待。

public class DeadlockExample {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread1: Holding resource 1...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.println("Thread1: Waiting for resource 2...");
                synchronized (resource2) {
                    System.out.println("Thread1: Holding resource 1 & 2...");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread2: Holding resource 2...");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.println("Thread2: Waiting for resource 1...");
                synchronized (resource1) {
                    System.out.println("Thread2: Holding resource 1 & 2...");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}