多线程

最新推荐文章于 2025-05-23 17:03:50 发布

酸奶解酒

最新推荐文章于 2025-05-23 17:03:50 发布

阅读量84

点赞数

文章标签：多线程 java

本文链接：https://blog.youkuaiyun.com/weixin_43751188/article/details/114027453

版权

本文详细介绍了Java中的程序、进程、线程和并发的概念，以及线程的创建方式，包括继承Thread类、实现Runnable接口、实现Callable接口和使用线程池。此外，还讨论了线程的优先级、线程安全与同步机制，如synchronized和Lock，并给出了线程通信的经典案例——生产者消费者问题。文章涵盖了Java多线程编程的基础知识和实践应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、概念：

1、程序：

程序是为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

2、进程：

进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有他自身的产生、存在和消亡的过程。
这个过程即是进程的生命周期。

3、线程：

进程进一步细化为线程，是一个程序内部的一条执行路径，每个线程各自有一个虚拟机栈和一个程序计数器。

4、并行与并发

并行：多个CPU同时执行多个任务
并发：一个CPU同时执行多个任务(多个任务同时抢占cpu)

二、线程的创建：

1、通过java.long.Thread类来体现

声明一个Thread类的子类，这个子类中要重写Thread类中的run方法，将此线程要做的操作写到run方法中，然后调用
子类的.Thread()方法，子类的对象就可以被执行了。
start()方法的作用：1、启动当前线程。2、调用当前线程的run()方法。
由此可知，我们不能通过直接调用run方式启动线程，那样的话就只是单线程（只有主线程）而不是启动一个新线程。
若要编写的新线程只使用一次可以使用创建Thread类的匿名子类的方法

new Thread(){
	public void run(){
	}
}.start();

2、实现Runnable接口

1、创建一个实现了Runnable接口的类
2、实现类去实现Runnable中的抽象方法：run()
3、创建实现类的对象
4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5、通过Thread类的对象调用start()

3、实现Callable接口

JDK5.0新特性。实现Callable接口。需要借助Future接口的唯一实现类FutureTask辅助线程的对象创建和返回值获取（FutureTask还实现了Runnable接口），再创建Thread对象，将FutureTask类的对象作为构造器参数传入，完成线程的创建，最后调用start()方法完成线程启动。

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

public class MultiThreadTest3 {
	public static void main(String[] args) {
		MyThread3 myThread3 = new MyThread3();
		FutureTask futureTask = new FutureTask(myThread3);
		Thread thread = new Thread(futureTask);
		thread.start();
		
		try {
			Object sum = futureTask.get();
			//System.out.println(sum);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		System.out.println("我是主线程");

		// 匿名写法
		new Thread(new FutureTask(new Callable() {

			@Override
			public Object call() throws Exception {
				// 此线程执行需要执行的操作声明在call中
				int sum = 0;
				for (int i = 0; i <= 100; i++) {
					sum += i;
				}
				System.out.println("我是匿名新线程");
				return sum;// int类型赋值给Object,自动装箱
			}
		}) ).start();
	}
}

class MyThread3 implements Callable {

	@Override
	public Object call() throws Exception {
		// 此线程执行需要执行的操作声明在call中
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			sum += i;
		}
		System.out.println("我是新线程");
		return sum;// int类型赋值给Object,自动装箱
	}
}

4、使用线程池

JDK5.0新特性。使用线程池，提前创建好多个线程放入线程池中，使用时直接获取，使用完放回线程池中。（骑自行车出行）可以做到提高响应速度（减少线程创建的时间）和降低资源消耗（可重复利用线程）。利用Executors工具类创建线程池，然后提供Runnable(excute())或Callable(submit())接口的实现类的对象，执行指定线程的操作。最后，关闭线程池shutdown()。

import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadTest4 {
	public static void main(String[] args) {
		// 利用工具类Executors创建线程池
		ExecutorService threadPool = Executors.newFixedThreadPool(10);
		threadPool.submit(new MyThread4());// 适用于实现Callable接口的线程
		threadPool.execute(new MyThread5());// 适用于实现Runnable接口的线程
		threadPool.shutdown();

	}
}

class MyThread4 implements Callable{

	@Override
	public Object call() throws Exception {
		// 此线程执行需要执行的操作声明在call中
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			sum += i;
		}
		System.out.println("我是CALL新线程");
		return sum;
	}
	
}

class MyThread5 implements Runnable {

	@Override
	public void run() {
		// 此线程执行需要执行的操作声明在call中
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			sum += i;
		}
		System.out.println("我是RUN新线程");
	}

}

5、创建线程方式见的比较

JDK5.0前两种方式的比较（继承与实现）
继承方式的弊端：单继承约束下线程只能继承于Thread类，不能继承于其他的类
实现方式的优势：天然存在共享数据的情况，不需要将共享的数据设置为静态（有共享数据时）
Thread类实际上是Runnable接口的实现类
实现RUNNABLE接口与实现CALLABLE接口方式的比较
Runnable接口实现方法需要重写run()，但是run()方法没有返回值，Callable接口实现方式重写Call()方法，可以有返回值；
Runnable接口实现方法不能抛出异常，只能try-catch捕获异常,Callable接口实现方式可以throws抛出异常;
Runnable接口实现方法不支持泛型,Callable接口实现方式支持泛型;
Callable接口实现方式返回值需要借助FutureTask类获取返回值。
Callable接口比Runnable接口高级而且现在一般使用的都是实现Callable接口或线程池的方式。

二、Thread类的有关方法：

方试Thread中的常用方法:

start():启动当前线程: 调用当前线程的run()
run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread():静态方法，回执行当前代碍的线程
getName();获取当前线程的名字
setName():设置当前线程的名字
yield():释放当前cpu的执行权
join():在线基a中调用线型b的join(),此时线程a就进入阻塞状态，直到线盘b完全执行完以后，线型才结束阻塞状态。
stop():已过时。当执行此方法时，强制结束当前线程。
sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive():判断当前线程是否存减

三、线程优先级：

1*线程的优先级:

”MAX_ PRIORITY: 10

米MIN PRIORITY: 1

NORM_ PRIORITY: 5 --> 默认优先级

2.如何获取和设置当前线程的优先级:

getpriority():获取线程的优先级

setPriority(int p): 设置线程的优先级

说明:高优先级的线程要抢占低优先级艘程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味者只有当高优先级的线程执行完以后，低优先级的线程才执行。

四、线程安全与同步：

线程安全问题产生原因：当一个线程在执行操作共享数据的多条代码过程中，其他线程也参与了运算，就有可能导致线程安全问题的产生。
解决方案：同步机制（三种）

方式一：同步代码块

将共享数据资源的代码块“包”起来，加synchronized关键字和同步锁。

synchronized(同步监视器（锁）){ //同步监视器（锁）可以是任意*对象*
//需要被同步的代码块
}

说明：
操作共享数据的代码即为需要被同步的代码；
多个线程共同操作的变量即为共享数据；
任何一个类的对象都能作为锁；多个线程必须共用一把锁，比如用继承方式创建线程需要设置锁对象为静态。
在实现Runnable接口方式创建线程中，解决线程安全问题，锁可以设置为当前对象，即用关键字this表示，synchronized(this){同步代码块}；
在继承方式创建线程中，解决线程安全问题，锁可以设置为类.class,即synchronized(继承Thread的子类.class){同步代码块};（因为在继承方式中实现的类是唯一的，也就是使用的是同一把锁）。
在操作同步代码块时，只有一个线程参与，其他线程等待，相当于一个单线程的过程，效率低。

方式二：同步方法：

如果操作共享数据的代码完整声明在一个方法中，不妨将此方法声明为同步的。
在继承方式创建线程时，可以直接把操作共享数据的代码封装进一个方法里,并把该方法声明为静态和同步，即static和synchronized，这里的隐藏同步监视器即为当前类本身（默认的）,类.class。
在实现方式创建线程时，可以直接把操作共享数据的代码封装进一个方法里，并把该方法声明为synchronized，这里实际上仍然有隐藏同步监视器存在，即为this。必要情况下，可以直接把run()方法设置为synchronized,但是相当于变成一个单进程过程，共享数据会被第一个进程全部执行。
方式三：同步锁（Lock）：
JDK5.0新特性，同步锁由Lock对象充当。ReentrantLock类实现Lock接口。
java.util.concurrent.locks.Lock接口：控制多个线程对共享数据资源进行访问的工具。锁提供了对共享数据资源的独占访问，每次只有一个线程对Lock对象加锁，线程开始访问共享数据资源之前需要先获取Lock对象。
同样，使用继承创建线程需要主要lock对象的静态问题。
Lock锁就好像一个人为地上了一个锁，也需要人为地解锁。

ReentrantLock reentrantLock = new ReentrantLock();
try {
	//加锁
	reentrantLock.lock();
	//需要同步的代码块
}finally {
	//释放锁
	reentrantLock.unlock();
}

同步和Lock锁的不同之处：

synchronized机制属于在执行完同步代码后，会自动释放锁（隐式锁）；
Lock机制需要手动的启动和解锁（显示锁），且只有代码块锁，没有方法锁；

五、线程通信：

线程通信常用方法：

wait():定义在Object类，final,线程进入阻塞状态，释放锁（和sleep不同）；
notify():定义在Object类，final,唤醒正在等待锁的线程，进入就绪状态（有优先级按优先级，没有随机唤醒一个）；
notifyAll():定义在Object类，final,唤醒所有正在等待锁的线程；
这三种方法只能出现在同步代码块或同步方法里，且不能用在lock里，否则会报错java.lang.IllegalMonitorStateException: current thread not owner。
这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，默认情况下是this或者类.class（当前类的对象）
sleep和wait的异同：
同：一旦使用，均可使当前线程进入阻塞状态；
异：
声明位置不同：sleep()声明在Thread类中，wait()声明在Object类中；
调用要求不同：sleep()可以使用在各种需要的地方，而wait()只能用在同步代码块或同步方法里；
sleep()使用不释放锁，而wait()使用后会释放锁。
线程通信经典案例：生产者消费者问题：

/*
 * 线程通信经典问题：生产者与消费者
 * 生产者生产产品给店员，消费者从店员消费产品，店员一次只能固定最多持有一定数量的产品（比如：20件），
 * 当店员满额产品，生产者试图多生产产品时，店员会让生产者停一停；
 * 当店员产品不足，消费者试图继续消费时，店员会让消费者等一等；
 * */
public class ThreadCommExe {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Productor productor = new Productor(clerk);
		Customer customer = new Customer(clerk);
		Thread threadp = new Thread(productor);
		Thread threadc = new Thread(customer);
		threadp.setName("生产者线程1");
		threadc.setName("消费者线程1");
		threadp.start();
		threadc.start();
	}
}

//店员实际上是共享资源，生产者与消费者两个线程需要判断店员的存货情况
class Clerk {
	private int productCount = 0;

	public synchronized void prodeceRespone() {
		if(productCount<20) {
			productCount++;
			System.out.println(Thread.currentThread().getName()+"正在生产第"+productCount+"件产品");
			notify();
		}else {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public synchronized void customeRespone() {
		if(productCount>0) {
			System.out.println(Thread.currentThread().getName()+"正在消费第"+productCount+"件产品");
			productCount--;
			notify();
		}else {
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

//生产者线程
class Productor implements Runnable {
	private Clerk clerk;

	public Productor(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		System.out.println("疯狂生产中......");
		while(true) {
			clerk.prodeceRespone();
		}
	}
}

//消费者线程
class Customer implements Runnable {
	private Clerk clerk;

	public Customer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		System.out.println("疯狂消费中......");
		while(true){
			clerk.customeRespone();
		}
	}
}