基本概念
首先需要了解一些基本的概念
- 程序（Program）：为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象
- 进程（Process）：一个程序的执行过程，简单理解就是运行中的程序就叫进程。
- 线程（Thread）：进程可以进一步细化为线程，由多个线程组成一个进程，线程可以看作程序内部的一条执行路径。
关于进程：
- 若一个进程同一时间并行执行多个线程，就是支持多线程的
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，一个进程中的多个线程共享堆和方法区，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资 源可能就会带来安全的隐患。
进程与线程的关系
- 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
- 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事
使用多进程的优点
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序的结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
多线程何时用？
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时
线程的创建方式（JDK1.5之前）
在JDK1.5以前，线程创建由两种方式：
- 方式一：继承Thread类
- 方式二：实现Runnable接口
方式一：继承Thread类
步骤如下：
- 定义子类继承Thread类
- 子类中重写Thread类中的run方法
- 创建Thread子类对象，即创建了线程对象
- 调用线程对象start方法：启动线程，调用run方法
//1、继承Thread类
class MyThread extends Thread{
public MyThread() {
super();
}
//2、重写Thread类中的run方法
@Override
public void run() {
for(int i = 0; i < 100; i++){
System.out.println("子进程：" + i);
}
}
}
class TestThread {
public static void main(String[] args) {
//3、创建Thread对象
MyThread mt = new MyThread();
//调用start方法
mt.start();
}
}
注意点：
- 必须通过调用start方法来让JVM调用run方法，如果自己调用run方法就是普通方法，没有启动多线程模式
- run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定
- 想要启动多线程，必须调用start方法
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。
方式二：实现Runnable接口
步骤：
- 实现Runnable接口
- 重写Runnable接口的run()方法
- 通过Thread类含参构造器创建线程对象
- 将实现Runnable接口的子类作为实际参数传递给Thread类的构造器
- 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
//1. 实现Runnable接口
class MyRunnable implements Runnable{
//2.重写run方法
@Override
public void run() {
for (int i=0; i < 100; i++){
System.out.println("子进程："+ i);
}
}
}
public class TestRunnable {
public static void main(String[] args) {
//3. 通过Thread类含参构造器创建线程对象
MyRunnable mr = new MyRunnable();
//4. 将实现Runnable接口的子类作为实际参数传递给Thread类的构造器
Thread thread = new Thread(mr);
//5. 调用Thread类的start方法
thread.start();
}
}
Thread 相关方法
- Thread()：创建新的Thread对象
- Thread(String threadname)：创建线程并指定线程实例名
- Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接 口中的run方法
- Thread(Runnable target, String name)：创建新的Thread对象
- void start(): 启动线程，并执行对象的run()方法
- run(): 线程在被调度时执行的操作
- String getName(): 返回线程的名称
- void setName(String name):设置该线程名称
- static Thread currentThread(): 返回当前线程。在Thread子类中就 是this，通常用于主线程和Runnable实现类
- static void yield()：线程让步
- join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将 被阻塞，直到 join() 方法加入的 join 线程执行完为止
- static void sleep(long millis)：(指定时间:毫秒)
- stop(): 强制线程生命期结束，不推荐使用 boolean isAlive()：返回boolean，判断线程是否还活着
方式一和方式二的区别
- 继承Thread：线程代码存放Thread子类run方法中。
- 实现Runnable：线程代码存在接口的子类的run方法。
实现Runnable的好处
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线 程来处理同一份资源
线程的创建方式（JDK1.5之后）
方式三：实现Callable接口
与使用Runnable相比， Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
Future接口
- FutrueTask是Futrue接口的唯一的实现类
- FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
*
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
方式四：使用线程池
JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable
<T>Future<T>submit(Callable<T>task)：执行任务，有返回值，一般又来执行 Callable- void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运 行命令或者定期地执行
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 创建线程的方式四：使用线程池
*
* 好处：
* 1.提高响应速度（减少了创建新线程的时间）
* 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
* 3.便于线程管理
* corePoolSize：核心池的大小
* maximumPoolSize：最大线程数
* keepAliveTime：线程没有任务时最多保持多长时间后会终止
*
*
* 面试题：创建多线程有几种方式？四种
*/
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
线程的优先级
线程的优先等级
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5
线程优先级涉及的方法
- getPriority() ：返回线程优先值
- setPriority(int newPriority) ：改变线程的优先级
说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
线程的生命周期
线程的同步
多线程出现了安全问题：
- 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误
解决方法：
- 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行
Synchronized的使用方法
Java对于多线程的安全问题提供了专业的解决方式：同步机制
使用方法一：
//
synchronized (/*对象（锁）*/){
// 需要被同步的代码
}
使用方法二：
public synchronized void show (String name){
......
}
Lock的使用方法
Lock也是同步机制的一种方式，在JDK1.5以后提供
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
} finally{
lock.unlock();
}
}
}
注意：如果同步代码有异常，要将unlock()写入finally语句块
synchronized 与 Lock 的对比
-
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是 隐式锁，出了作用域自动释放
-
Lock只有代码块锁，synchronized有代码块锁和方法锁
-
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有 更好的扩展性（提供更多的子类）
同步机制中的锁
synchronized的锁是什么？
- 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class
注意：
- 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
- 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
同步的范围
如何找问题，即代码是否存在线程安全？
- 明确哪些代码是多线程运行的代码
- 明确多个线程是否有共享数据
- 明确多线程运行代码中是否有多条语句操作共享数据
如何解决？
- 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其 他线程不可以参与执行
- 即所有操作共享数据的这些语句都要放在同步范围中
记住
- 范围太小：没锁住所有有安全问题的代码
- 范围太大：没发挥多线程的功能。
锁的释放
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线 程暂停，并释放锁
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、 Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程 挂起，该线程不会释放锁（同步监视器），应尽量避免使用suspend()和resume()来控制线程
线程的通信
wait() 与 notify() 和 notifyAll()
- wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当 前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有 权后才能继续执行
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
- notifyAll ()：唤醒正在排队等待资源的所有线程结束等待
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁， 因此这三个方法只能在Object类中声明
扫一扫
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
