多线程1-10-CSDN博客

本文链接：https://blog.csdn.net/mingwangxingqqq/article/details/135920137

基础概念

线程创建

Thread class---继承Thread类（重点）
Runnable接口---实现Runnable接口（重点）
Callable接口---实现Callable接口（了解）

Thread

自定义线程类继承Thread 类
重写run（）方法，编写线程执行体
创建线程对象，调用start（）方法启动线程
不建议使用：避免OOP单继承局限性

public void run(){
        //run方法线程体
        for (int i=0;i<20;i++){
            System.out.println("我在---"+i);
        }

    }

    public static void main(String[] args) {
        //main线程，主线程

        test test = new test();


        //调用start方法开启线程
        test.start();


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

    }

实现Runnable接口

实现接口Runnable具有多线程能力
启动线程：传入对象+Thread对象。start（）
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

Runnable接口是一个函数式接口，其中只包含一个抽象方法run()，用于定义线程的执行逻辑。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running on thread: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

在这个示例中，我们首先创建了一个实现了Runnable接口的类MyRunnable。在MyRunnable类中，我们重写了run()方法，定义了线程的执行逻辑。然后在main()方法中，我们创建了一个Thread对象，并将MyRunnable对象作为参数传递给Thread的构造函数。最后调用start()方法启动线程。

通过实现Runnable接口，我们可以实现多线程的目的，并且可以更好地管理线程的生命周期和资源。另外，实现Runnable接口还可以更好地支持面向对象的编程风格，使得代码更具可读性和可维护性。

初识并发问题

1. 竞态条件（Race Condition）

竞态条件是指多个线程在访问共享资源时，由于执行顺序不确定而导致的问题。例如，两个线程同时对同一个计数器进行自增操作，由于执行顺序不确定，可能导致计数器值不正确。

public class RaceConditionExample {
    private static int counter = 0;

    public static void main(String[] args) {
        // 创建线程1，对counter进行自增操作
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter++;
            }
        });

        // 创建线程2，对counter进行自增操作
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter++;
            }
        });

        // 启动线程1和线程2
        thread1.start();
        thread2.start();

        try {
            // 等待线程1和线程2执行结束
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印最终的计数器值
        System.out.println("Counter: " + counter);
    }
}

在上面的示例中，两个线程同时对counter进行自增操作，由于执行顺序不确定，最终的计数器值可能不是预期的2000。

2. 死锁（Deadlock）

死锁是指多个线程因相互等待对方释放资源而无法继续执行的情况。例如，线程A持有资源1，等待资源2；线程B持有资源2，等待资源1，这时就会发生死锁。

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

    public static void main(String[] args) {
        // 创建线程1，尝试获取resource1，然后尝试获取resource2
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 1: Holding resource 1 and 2");
                }
            }
        });

        // 创建线程2，尝试获取resource2，然后尝试获取resource1
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource 2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for resource 1");
                synchronized (resource1) {
                    System.out.println("Thread 2: Holding resource 1 and 2");
                }
            }
        });

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

实现Callable接口

Callable接口类似于Runnable接口，但是它可以返回线程的执行结果，并且能够抛出异常。下面是一个简单的示例，演示了如何使用Callable接口创建一个线程并获取返回结果：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

// 实现Callable接口
public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int result = 0;
        for (int i = 0; i < 5; i++) {
            result += i;
        }
        return result;
    }

    public static void main(String[] args) {
        // 创建MyCallable实例
        MyCallable myCallable = new MyCallable();
        // 使用FutureTask包装MyCallable实例
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);

        // 创建新线程并启动
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            // 获取线程执行结果
            int result = futureTask.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们创建了一个实现Callable接口的MyCallable类，然后使用FutureTask来包装MyCallable实例，最后将FutureTask传递给一个新的线程并启动它。通过调用futureTask.get()方法，我们可以获取线程的执行结果。

静态代理模式

静态代理模式是一种设计模式，用于控制对对象的访问。在多线程编程中，静态代理模式可以用来管理对线程的访问，例如限制对线程的调用次数、记录线程的执行日志等。下面是一个简单的示例，演示了如何使用静态代理模式控制对多线程的访问：

// 静态代理模式
// 定义线程操作接口
public interface ThreadOperation {
    void start();
}

// 实现线程操作接口的类
public class RealThreadOperation implements ThreadOperation {
    @Override
    public void start() {
        System.out.println("Real thread is starting...");
    }
}

// 代理类
public class ThreadProxy implements ThreadOperation {
    private ThreadOperation realThread;

    public ThreadProxy(ThreadOperation realThread) {
        this.realThread = realThread;
    }

    @Override
    public void start() {
        System.out.println("Proxy is starting...");
        // 调用实际线程操作前后添加逻辑
        realThread.start();
        System.out.println("Proxy is ending...");
    }

    public static void main(String[] args) {
        // 创建实际线程操作实例
        RealThreadOperation realThread = new RealThreadOperation();
        // 创建代理类实例
        ThreadProxy threadProxy = new ThreadProxy(realThread);
        // 调用代理类的start方法
        threadProxy.start();
    }
}

在上面的示例中，我们定义了一个ThreadOperation接口和一个实现了该接口的RealThreadOperation类，然后创建了一个ThreadProxy类作为RealThreadOperation的代理类。在ThreadProxy中，我们可以在调用realThread.start()前后添加一些额外的逻辑，以控制对RealThreadOperation的访问。