一、进程与线程
(一)进程的概述
进程是程序的一次执行过程,是系统进行资源分配和调度的一个独立单位。每个进程都有自己独立的内存空间,包括代码、数据和运行时的环境。进程的执行需要系统为其分配各种资源,如 CPU 时间、内存空间、文件描述符等。
(二)线程的概述
线程是进程中的一个执行单元,是操作系统能够进行运算调度的最小单位。一个进程可以包含多个线程,这些线程共享进程的内存空间和资源,同时又有各自独立的执行路径。线程的创建和切换比进程更加轻量级,因此在多任务处理中,线程的使用可以提高系统的并发性和效率。
二、线程的创建
(一)继承Thread类创建多线程
通过继承 java.lang.Thread 类来创建一个线程。具体步骤如下:
1.定义一个子类继承 Thread 类。
2.重写 Thread 类的 run () 方法,在 run () 方法中编写线程要执行的任务代码。
3.创建子类的实例对象。
4.调用实例对象的 start () 方法启动线程。
public class MyThread extends Thread {@Overridepublic void run() {System.out.println("继承 Thread 类创建多线程。");}
}public class ThreadCreationExample {public static void main(String[] args) {MyThread thread = new MyThread();thread.start();}
}
(二)实现Runnable接口创建多线程
实现 java.lang.Runnable 接口也是创建线程的一种方式。步骤如下:
1.定义一个类实现 Runnable 接口。
2.实现 Runnable 接口中的 run () 方法,在 run () 方法中编写线程要执行的任务代码。
3.创建实现类的实例对象。
4.将实例对象作为参数传递给 Thread 类的构造方法,创建 Thread 对象。
5.调用 Thread 对象的 start () 方法启动线程。
public class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("实现 Runnable 接口创建多线程。");}
}public class RunnableCreationExample {public static void main(String[] args) {MyRunnable runnable = new MyRunnable();Thread thread = new Thread(runnable);thread.start();}
}
(三)实现Callable接口创建多线程
实现 java.util.concurrent.Callable 接口可以创建有返回值的线程。步骤如下:
1.定义一个类实现 Callable 接口,并指定返回值类型。
2.实现 Callable 接口中的 call () 方法,在 call () 方法中编写线程要执行的任务代码,并返回结果。
3.创建实现类的实例对象。
4.将实例对象作为参数传递给 java.util.concurrent.ExecutorService 的 submit () 方法,提交任务并返回一个 Future 对象。
5.可以通过 Future 对象的 get () 方法获取线程的执行结果。
public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {return "实现 Callable 接口创建的线程返回的结果。";}
}public class CallableCreationExample {public static void main(String[] args) throws ExecutionException, InterruptedException {MyCallable callable = new MyCallable();FutureTask<String> futureTask = new FutureTask<>(callable);Thread thread = new Thread(futureTask);thread.start();String result = futureTask.get();System.out.println(result);}
}
三、线程的生命周期及状态转换
(一)新建状态
当一个线程对象被创建后,它就处于新建状态。此时线程还没有开始执行,仅仅是一个对象的存在。
(二)可运行状态
当线程对象调用 start () 方法后,线程进入可运行状态。在这个状态下,线程可能正在运行,也可能在等待 CPU 时间片。
(三)锁阻塞状态
当线程试图获取一个被其他线程占用的锁时,它会进入锁阻塞状态。直到锁被释放,线程才能重新进入可运行状态。
(四)无限等待状态
当线程调用了某些方法,如 Object.wait ()、Thread.join () 等,线程会进入无限等待状态。在这个状态下,线程会一直等待,直到被其他线程唤醒。
(五)计时等到状态
当线程调用了某些带有超时时间的方法,如 Object.wait (long timeout)、Thread.join (long millis) 等,线程会进入计时等到状态。如果在超时时间内没有被唤醒,线程会自动进入可运行状态。
(六)被终止状态
当线程的 run () 方法执行完毕或者线程被中断,线程会进入被终止状态。此时线程不再执行任何任务,并且不能再被启动。
四、线程操作的相关方法
(一)线程优先级
优先级常量 | 功能描述 |
static int MAX_PRIORITY | 表示线程的最高优先级,值为10 |
static int MIX_PRIORITY | 表示线程的最低优先级,值为1 |
static int NORM_PRIORITY | 表示线程的默认优先级,值为5 |
Thread thread1 = new Thread(() -> System.out.println("线程 1"));
Thread thread2 = new Thread(() -> System.out.println("线程 2"));
thread1.setPriority(Thread.MIN_PRIORITY);
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();
(二)线程休眠
线程可以通过 Thread.sleep (long millis) 方法进入休眠状态,指定的时间过后,线程会自动唤醒并进入可运行状态。
Thread thread = new Thread(() -> {try {System.out.println("线程开始执行");Thread.sleep(2000);System.out.println("线程休眠 2 秒后继续执行");} catch (InterruptedException e) {e.printStackTrace();}
});
thread.start();
(三)线程插队
在 Java 中没有直接的线程插队方法,但是可以通过设置线程优先级来影响线程的执行顺序。优先级高的线程可能会在某些情况下 “插队” 先执行。
(四)线程让步
线程可以通过 Thread.yield () 方法主动让出 CPU 时间片,让其他同优先级的线程有机会执行。但是不能保证让步后的线程一定不会再次被调度执行。
Thread thread = new Thread(() -> {for (int i = 0; i < 5; i++) {System.out.println("线程执行中");Thread.yield();}
});
thread.start();
(五)线程中断
可以通过调用线程的 interrupt () 方法来中断一个线程。被中断的线程可以通过 isInterrupted () 方法来检查自己是否被中断,并根据需要进行相应的处理。
Thread thread = new Thread(() -> {while (!Thread.currentThread().isInterrupted()) {System.out.println("线程执行中");}System.out.println("线程被中断");
});
thread.start();
try {Thread.sleep(1000);
} catch (InterruptedException e) {e.printStackTrace();
}
thread.interrupt();
五、线程同步
(一)线程安全
当多个线程同时访问共享资源时,如果不进行同步控制,可能会导致数据不一致等问题。确保在多线程环境下正确处理对共享资源的并发访问就是线程安全。
(二)同步代码块
synchronized (lock) {处理共享资源的代码块
}
(三)同步方法
//synchronized 返回值类型 方法名([参数列表]){}public class Counter {private int count = 0;public synchronized void increment() {count++;}public int getCount() {return count;}
}public class SynchronizedMethodExample {public static void main(String[] args) {Counter counter = new Counter();Thread thread1 = new Thread(counter::increment);Thread thread2 = new Thread(counter::increment);thread1.start();thread2.start();try {thread1.join();thread2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(counter.getCount());}
}
(四)死锁问题
当两个或多个线程相互等待对方持有的资源,而导致所有线程都无法继续执行的情况称为死锁。为了避免死锁,在设计多线程程序时,应该尽量避免多个线程同时持有多个锁,并且要确保在获取锁的顺序上是一致的。同时,应该及时释放不再需要的锁,避免资源的长时间占用。
public class ResourceA {public synchronized void useA(ResourceB resourceB) {System.out.println("线程持有资源 A,尝试获取资源 B");resourceB.useB();}
}public class ResourceB {public synchronized void useB() {System.out.println("线程持有资源 B,尝试获取资源 A");}
}public class DeadlockExample {public static void main(String[] args) {ResourceA resourceA = new ResourceA();ResourceB resourceB = new ResourceB();Thread thread1 = new Thread(() -> resourceA.useA(resourceB));Thread thread2 = new Thread(() -> resourceB.useB());thread1.start();thread2.start();}
}