基础概念
线程创建
- 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
的访问。