JavaSE 拾遗(7)——JavaSE 多线程

最新推荐文章于 2024-05-10 11:26:21 发布

楼上的大叔阿

最新推荐文章于 2024-05-10 11:26:21 发布

阅读量1.3k

点赞数

分类专栏： OOP.Java.SE.JRE.API 文章标签：多线程 java 编程语言 Java SE

本文链接：https://blog.csdn.net/zhaoyw2008/article/details/8991595

版权

OOP.Java.SE.JRE.API 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

前面的博客主要说了 java 语言的相关内容，下面的博客说 javase 类库框架相关的类容。在 java 语言里面，多线程是用 Thread 类和 Runable 接口来实现的，我认为这个应该不属于基础的语言规则，但是 javase 还是把这两个类放在了 java.lang 包下面，是不是因为所有的编程语言都必须支持多线程这个基本的特性，或者因为java里面线程同步用的关键字 synchronized ，是 java 语言级的东西。其实多线程这个特性是操作系统提供的。和异常类似的是，多线程相关的内容，线程创建部分内容是 javase 框架的类库中 Thread 类和 Runable 接口实现的，而线程同步部分中，部分内容是synchronized 关键字实现的，部分内容是类库中的功能实现的。

多线程部分相关内容有

进程和线程的概念
线程的创建方法
多线程间的同步
多线程间的通信
停止线程
线程合并
守护线程

进程和线程的概念

进程和线程，都是并发程序设计里面产生的概念，并发并不是真正的并行，当然现在多核cpu可以算并行了，以前单核cpu的时候，并发程序由于切换特别快，看起来好像多个程序时同时运行。程序主要是指硬盘上保存的程序的文件，是静态的概念，进程主要是程序被加载到内存中，被cpu或者操作系统执行时的概念，是动态概念，一个进程就是指一个计算机任务。进程是任务的基本单位，线程是cpu的基本单位。

线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作，称为多线程.要弄清楚线程，须结合进程加以理解：
进程是一个可执行的程序，由私有虚拟地址空间、代码、数据和其他操作系统资源（如进程创建的文件、管道、同步对象等）组成。一个应用程序可以有一个或多个进程，一个进程可以有一个或多个线程，其中一个是主线程。
线程是操作系统分时调度分配CPU时间的基本实体。一个线程可以执行程序的任意部分的代码，即使这部分代码被另一个线程并发地执行；一个进程的所有线程共享它的虚拟地址空间、全局变量和操作系统资源。之所以有线程这个概念，是因为以线程而不是进程为调度对象效率更高：由于创建新进程必须加载代码，而线程要执行的代码已经被映射到进程的地址空间，所以创建、执行线程的速度比进程更快。一个进程的所有线程共享进程的地址空间和全局变量，所以简化了线程之间的通讯。

有时候，线程也称作轻量级进程。就象进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存、文件句柄和其它每个进程应有的状态。多个线程之间，看似同时执行，但互相之间并不同步(所以需要 synchronized 来实现模拟同步的协调， synchronized 主要使用互斥锁实现)。一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易，但您必须小心，确保它们不会妨碍同一进程里的其它线程。

进程和线程在内存中的结构如下图所示

总结起来，就是多线程之间共享堆，独立栈。

jvm 中的线程和这个稍有不同：

线程的创建方法

构建 Thread 类子类的方法
实现 Runable 接口的方法

构建 Thread 类子类的方法

在面向对象程序里面，一个应用程序是一个对象，一个线程也是一个对象，只是应用程序对象和线程对象是组合的关系。应用程序类依赖于线程类。他们在构造关系上，应用程序属于上层类，线程属于下层类，线程是应用程序的组成元素，但是它们不是继承上的关系，而是组合的关系。所以上下层关系，在面向对象里面有两种，一种是继承这种概念上抽象层次的上下层关系，一种是组合这种，拆分层次上的上下层关系。线程既然由 Thread 类来描述，那么 Thread 类主要对外提供了线程操作相关的接口。

start() 启动线程
run() 线程启动后执行的函数
interrupt() 中断线程
join() 合并线程
sleep(long millis) 让当前线程休眠
setDaemon(boolean on) 设置线程为守护线程
setPriority(int newPriority) 设置线程优先级
setName(String name) 设置线程名
其他获取线程相关信息的接口，还有几个线程相关的操作在 Object 类中描述的

创建线程实例

/**
需求:演示通过构造 Thread 子类，创建线程

思路:创建一个线程，打印和main线程不同东西

步骤:
1.定义类继承Thread。
2.复写Thread类中的run方法。
3.调用线程的start方法，该方法两个作用，启动线程，调用run方法
*/
class PrintedThread extends Thread
{
	public void run()
	{
		for(int count=0; count < 100; count++)
		{
			System.out.println("child thread run..." + count);
		}
	}
}

class ThreadCreated 
{
	public static void main(String[] args) 
	{
		PrintedThread printedThread = new PrintedThread();
		printedThread.start();
		for(int count=0; count < 100; count++)
		{
			System.out.println("main thread run..." + count);
		}
	}
}

这种覆盖 run 方法的模式，其实就是《JavaSE 拾遗(5)——JavaSE 面向对象程序设计语言基础(5)》中的模板方法模式，有木有！

Thread 类用于描述线程，该类就定义了一个功能 run 用于存储线程要运行的代码。

获取线程名称和获取当前线程对象

Thread 类中的成员函数

String getName() 可以获取线程对象的标志名，线程对象默认标志名是 Thread-编号，编号从0开始。

setName() 可以设置线程对象的标志名

static Thread currentThread() 返回当前正在执行的线程对象的引用

实现 Runable 接口来创建线程

/**
需求:演示实现 Runnable 接口的方法来创建进程

思路:

步骤:
1.定义类实现 Runnable 接口
2.覆盖 Runnable 接口中的 run 方法
3.通过 Thread 类建立线程对象
4.将 Runnable 接口的子类对象作为参数传递给 Thread 类对象的构造函数
5.调用 Thread 类的 start 方法开启线程

总结： Runnable 接口是把 Thread 中未知功能封装起来了，让别的类来实现
      Runnalbe 接口之后，再把对象的应用传给 Thread 类对象，那么就实
	  现了 Thread 对象启动新线程后去运行，run 中的方法。Runnable 接
	  口对 Thread 类的功能进行了扩展。
*/
class HelloJava implements Runnable
{
	void run()
	{
		while(true)
		{
			System.out.println("Hello Java!");
		}
	}
}

class MultiThread
{
	public static void main(String[] args) 
	{
		Runnable helloJava = new helloJava();
		Thread threadPrint = new thread(helloJava);
		while(true)
		{
			System.out.println("Hello World!");
		}
	}
}

多线程同步

同步代码块方法
同步函数方法

线程有7种状态

1、线程的实现有两种方式，一是继承Thread类，二是实现Runnable接口，但不管怎样，当我们new了这个对象后，线程就进入了初始状态;
　　2、当该对象调用了start()方法，就进入可运行状态;
　　3、进入可运行状态后，当该对象被操作系统选中，获得CPU时间片就会进入运行状态;
　　4、进入运行状态后情况就比较复杂了
　　4.1、run()方法或main()方法结束后，线程就进入终止状态;
　　4.2、当线程调用了自身的sleep()方法或其他线程的join()方法，就会进入阻塞状态(该状态既停止当前线程，但并不释放所占有的资源)。当sleep()结束或join()结束后，该线程进入可运行状态，继续等待OS分配时间片;
　　4.3、线程调用了yield()方法，意思是放弃当前获得的CPU时间片，回到可运行状态，这时与其他进程处于同等竞争状态，OS有可能会接着又让这个进程进入运行状态;
　　4.4、当线程刚进入可运行状态(注意，还没运行)，发现将要调用的资源被synchroniza(同步)，获取不到锁标记，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于池状态，既随机得到锁)，一旦线程获得锁标记后，就转入可运行状态，等待OS分配CPU时间片;
　　4.5、当线程调用wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，与阻塞状态不同)，进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒(由于notify()只是唤醒一个线程，但我们由不能确定具体唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。

同步代码块方法

/**
需求:演示多线程同步

思路:用线程表示售票员，多个售票员操作共同卖100张票

步骤:

问题原因：
	当多条语句在操作多个线程的共享数据的时候，一个线程对这多条语句只执行了一小部分
	还没有执行完对共享数据所有操作，就切换到另一个共享数据的线程，导致对共享数据的
	操作形成错误。

解决方法：
	对多条语句操作共享数据的线程，只能让一个线程都执行完这些语句，才能让另外的一个
	线程执行这些共享数据操作的语句。则就是线程同步。

	java 提供了同步代码块和同步函数两种方法实现同步。

	synchronized 机制实际是互斥锁机制，Ojbect 对象都有锁数据成员变量，用来描述锁的
	状态，java 还会把没有得到锁的线程置为锁池状态，锁池并不真正存在，是一个逻辑上的集
	合，进入锁池的线程在置为可以运行状态之后再去拿钥匙(判断锁的状态)，如果拿到钥匙就运行，
	如果没有拿到就再次回到锁池状态。sychronized 块运行完之后无论是否运行都要还钥匙(开锁)
	由于线程转到运行态是随机的，所以拿到钥匙的线程也是随机的。

同步的前提：
1.必须是2个或者2个以上线程，用使用多条语句操作多线程共享数据。
2.必须使用同一个锁。
*/
class Ticket implements Runnable
{
	private int ticketCount = 100;

	public void run()
	{
		while(true)
		{
			//synchronized(this)
			synchronized(Ticket.class)
			{
				if(ticketCount > 0)
				{
					try{Thread.sleep(10);}catch(Exception e){}
					System.out.println(Thread.currentThread().getName() + "...sale:" + ticketCount--);
				}
				else
				{
					break;
				}
			}
		}
	}
}

class TicketDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread ticketSeller01 = new Thread(t);
		Thread ticketSeller02 = new Thread(t);
		Thread ticketSeller03 = new Thread(t);
		Thread ticketSeller04 = new Thread(t);
		Thread ticketSeller05 = new Thread(t);

		ticketSeller01.start();
		ticketSeller02.start();
		ticketSeller03.start();
		ticketSeller04.start();
		ticketSeller05.start();

		System.out.println("over!");
	}
}

同步函数方法

/**
需求:演示多线程同步函数方法

思路:银行有一个金库，有两个储户分别存300元，每次存100，存3次

步骤:

如何找出多线程同步问题:
1.明确哪些代码是多线程代码
2.明确哪些共享数据
3.明确多线程共享代码哪些代码是操作共享数据的

总结：
1.同步函数使用的锁是 this 对象
2.静态同步函数使用的锁是函数所属类的 *.class 文件加载后形成的 Class 对象
静态成员进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象，
该对象名是 类名.class，对象类型是 Class。
*/
class Bank
{
	private int totalDeposits = 0;
	
	//因为整个函数中的代码都具有同步性，所以直接用同步函数
	public synchronized void add(int amount)
	{
		totalDeposits += amount;
		try{Thread.sleep(10);}catch(Exception e){}
		System.out.println("totalDeposits = " + totalDeposits);
	}
}

class Depositor implements Runnable
{
	private Bank bank;

	public Depositor(Bank bank)
	{
		this.bank = bank;
	}

	public void run()
	{
		for(int count = 0; count < 3; count++)
		{
			bank.add(100);
		}
	}
}

class BankDemo
{
	public static void main(String[] args) 
	{
		Bank icbc = new Bank();
		Thread sheldon = new Thread(new Depositor(icbc));
		Thread spock = new Thread(new Depositor(icbc));
		sheldon.start();
		spock.start();

		System.out.println("game over!");
	}
}

多线程死锁

死锁经常发生在嵌套 synchronized ，并且锁对象不同的时候。

class Test1 implements Runnable
{
	private boolean flag;
	Test1(boolean flag)
	{
		this.flag = flag;
	}
	public void run()
	{
		 if(flag)
		 {
			 while(true)
			{
				 synchronized(MyLock.locka)
				 {
					 System.out.println("if locka");
					 synchronized(MyLock.lockb)
					 {
						 System.out.println("if lockb");
					 }
				 }
			 }
		 }
		 else
		 {
			 while(true)
			 {
				 synchronized(MyLock.lockb)
				 {
					 System.out.println("else lockb");
					 synchronized(MyLock.locka)
					 {
						 System.out.println("elcs locka");
					 }
				 }
			 }

		 }
	}
}

class MyLock
{
	static Object locka = new Object();
	static Object lockb = new Object();
}
class  DeadLockTest
{
	public static void main(String[] args) 
	{
		new Thread(new Test1(true)).start();
		new Thread(new Test1(false)).start();
	}
}

线程之间通信

线程间通信，是指线程之间交换数据。通常一个线程往共享数据区写数据，另一个线程往共享数据区读数据，就形成线程间通信，他们之间除了有前面说得（互斥那种）同步关系，还有固定的执行顺序，必须是写的线程完成后，才能执行读的线程。这种同步关系，java 提供了等待唤醒机制来实现。

等待唤醒方法1，Object 提供的 wait 和 notify 方法，因为 wait notify 是让当前线程主动放弃拿到的锁，所以这两个方法和锁密切相关，是要操作锁状态的方法，因为 java 里面，每个对象都可以有锁这个成员，所以锁在 Objec 中定义，那么 wait notify 也因此在 Object 中被定义。

生产者-消费者实例

/**
需求:使用线程间通信演示多个生产者-消费者模型

思路:

步骤:
*/
class ProducerConsumerDemo
{
	public static void main(String[] args) 
	{
		Resource resource = new Resource();

		Thread producer01 = new Thread(new Producer(resource));
		Thread producer02 = new Thread(new Producer(resource));
		Thread consumer01 = new Thread(new Consumer(resource));
		Thread consumer02 = new Thread(new Consumer(resource));

		producer01.start();
		producer02.start();
		consumer01.start();
		consumer02.start();
	}
}

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;

	public synchronized void set(String name)
	{
		while(flag)
		{
			try{this.wait();}catch(Exception e){}		
		}
		this.name = name+"---"+count++;

		System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
		flag = true;
		this.notifyAll();
	}
	
	public synchronized void out()
	{
		
		while(!flag)
		{
			try{this.wait();}catch(Exception e){}		
		}
		System.out.println(Thread.currentThread().getName() + "...消费者..." + this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource resource;

	public Producer(Resource resource)
	{
		this.resource = resource;
	}

	public void run()
	{
		while(true)
		{
			resource.set("商品");
		}
	}
}

class Consumer implements Runnable
{
	private Resource resource;

	public Consumer(Resource resource)
	{
		this.resource = resource;
	}

	public void run()
	{
		while(true)
		{
			resource.out();
		}
	}
}

wait()、notify()和notifyAll()
当使用 object.wait 的时候，会使当前线程释放 object 锁，并使当前线程阻塞，放入 wait 线程池队列中。notify唤醒的都是线程池中的线程，通常是线程池中的第一个线程。notifyAll唤醒线程池中的所有阻塞线程，把这些线程从等待状态置为锁池状态。

这三个方法都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步的时候才具有锁。

为什么这些操作线程的方法要定义在Object类中呢？
因为这些方法在操作同步中线程时，都必须要标示它们所操作线程持有的锁。只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒是对锁进行操作(实际上时改变锁对象的对象头中的锁状态位)。而锁可以是任意对象，而能被任意对象调用的方法定义在Object类中，所以把这三个方法定义在 Object 类中。

线程同步中的 Lock 和 Condition 接口

/**
需求:使用 Lock 和 Condition 接口实现，生产者-消费者模型

思路:
1.生产者-消费者，是同时进行各自的操作，所以有多少个生产者和消费者
就需要多少个线程。
2.生产者、消费者都和产品有关系。
3.生产者生产好产品后存在仓库，消费者从仓库取产品来消费
4.生产者只能在仓库没有放满的时候才生产
5.消费者只能在仓库还有产品的时候才消费
6.仓库现在暂时定为只能放1个产品，后面会扩建仓库，让仓库放更多产品
7.产品进出仓库都要把产品序列号记下，这里是直接打印到屏幕上
所以有 生产者 消费者 产品 仓库 线程 这些对象来完成整个系统


步骤:
步骤如代码所示，先整体后局部，先抽象后具体，依赖接口(依赖倒转)

 */
package cn.itcast.multithread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ProducerConsumerDemo {
	public static void main(String[] args) {
		Storage storageBox = new StorageBox();

		Thread producer01 = new Thread(new Producer(storageBox));
		Thread producer02 = new Thread(new Producer(storageBox));

		Thread consumer01 = new Thread(new Consumer(storageBox));
		Thread consumer02 = new Thread(new Consumer(storageBox));

		producer01.start();
		producer02.start();
		consumer01.start();
		consumer02.start();
	}
}

interface Storage {
	void saveProduce(Produce produce) throws InterruptedException;

	Produce getProduce() throws InterruptedException;
}

class StorageBox implements Storage {
	private Produce produce = null;
	private boolean isFull = false;
	private final Lock lock = new ReentrantLock();
	final Condition notFull = lock.newCondition();
	final Condition notEmpty = lock.newCondition();

	public void saveProduce(Produce produce) throws InterruptedException {
		lock.lock();
		try {
			if (isFull) {
				notFull.await();
			} else {
				this.produce = produce;
				System.out.println("存入产品" + produce.getNumber());
				isFull = true;
				notEmpty.signal();
			}
		} finally {
			lock.unlock();
		}
	}

	public Produce getProduce() throws InterruptedException {
		Produce produce = null;
		lock.lock();
		try {
			if (!isFull) {
				notEmpty.await();
			} else {
				isFull = false;
				produce = this.produce;
				System.out.println(Thread.currentThread().getName() + "取出产品"
						+ produce.getNumber());
				notFull.signal();
			}
		} finally {
			lock.unlock();
		}
		return produce;
	}
}

class Producer implements Runnable {
	private Storage storage;
	private int number = 0;

	Producer(Storage storage) {
		this.storage = storage;
	}

	public void run() {
		while (true) {
			try {
				this.number++;
				storage.saveProduce(make(Thread.currentThread().getName() + "#"
						+ this.number));
			} catch (InterruptedException e) {
			}
		}
	}

	private Produce make(String produceNumber) throws InterruptedException {
		return new Produce(produceNumber);
	}
}

class Consumer implements Runnable {
	Storage storage;

	Consumer(Storage storage) {
		this.storage = storage;
	}

	public void run() {
		while (true) {
			try {
				useProduce();
			} catch (InterruptedException e) {
			}
		}
	}

	private void useProduce() throws InterruptedException {
		storage.getProduce();
	}
}

class Produce {
	private String produceNumber;

	Produce(String produceNumber) {
		this.produceNumber = produceNumber;
	}

	public String getNumber() {
		return produceNumber;
	}
}

JDK1.5中提供了多线程的升级解决方案：将同步synchronized替换成Lock接口操作；将Objec（监视器对象）的wait，notify，notifyAll，替换成Condition接口的相应操作，Condition对象可以通过Lock锁进行获取。这是一种显式的锁机制和显式的锁对象上的等待唤醒操作机制，它把等待唤醒动作封装成了Condition类对象，让一个锁可以对应多个Condition对象（监视器对象），即一个锁可以对应多组wait-notify。

停止线程

当线程处于 wait 或者 sleep join 等阻塞状态时，需要强行停止当前阻塞状态，可以使用 Thread 对象的 interrupt 方法。

实例

/**
需求:使用 interrupt 方法让线程退出阻塞状态

思路:

步骤:

总结：
如何停止线程,因为 stop 方法由于安全原因已经过时，现在只有一个方法停止线程，那就是run方法运行结束。开启多线程运行，运行代码通常是
循环结构，所以要想run方法结束，只要控制住循环结束就可以，也就是可以结束线程。

特殊情况下，当线程处于阻塞状态，就不会读取到循环结束标记，那么线程就可能永远不能结束。线程资源就可能永远不释放，这时需要 Thread
对象提供的 interrupt 方法来中断线程的阻塞状态。interrupt 中断，是中断线程的现在的状态，使线程主动退出阻塞状态。
*/
class InterruptDemo 
{
	public static void main(String[] args) 
	{
		Wait wait = new Wait();
		Thread thread = new Thread(wait);

		thread.start();
		try
		{
			Thread.sleep(100);
		}
		catch (Exception e)
		{
		}
		
		wait.setFlag(false);
		thread.interrupt();

		System.out.println("game over!");
	}
}

class Wait implements Runnable
{
	private boolean flag = true;

	public synchronized void run()
	{
		while(flag)
		{
			try
			{
				wait();
			}
			catch (InterruptedException e)
			{
				System.out.println("InterruptedException");
			}
		}
	}

	public void setFlag(boolean flag)
	{
		this.flag = flag;
	}
}

守护线程

守护线程就是后台线程，后台线程存在的作用就是为前台线程服务的，如果非守护线程都结束，java虚拟机就退出运行，后台线程自动结束。就像雅典娜和圣斗士的关系，圣斗士存在的意义就是守护雅典娜，如果雅典娜不存在了，圣斗士也就没有存在的意义了。Thread 为对象提供 setDaemon 方法来设置线程为守护线程，这个方法只能在启动线程前调用。

合并线程

如果一个父线程在某个位置需要和另一个子线程合并在一起，也就是一个父线程需要在某个位置等待另一个子线程结束后再运行。Thread 提供了 join 方法，在父线程语句中，通过子线程对象，调用 join 方法，就实现了在父线程该语句等待子线程合并。

/**
需求:线程合并

思路:

步骤:
*/
class ThreadJoin
{
	public static void main(String[] args) throws InterruptedException
	{
		Thread childThread = new Thread(new ChildThread());
		childThread.start();
		childThread.join();
		System.out.println("game over!");
	}
}

class ChildThread implements Runnable
{
	public void run()
	{
		try
		{
			Thread.sleep(100);
		}
		catch (InterruptedException e)
		{
		}

		System.out.println("child thread joined");
	}
}

多线程程序设计图示：

楼上的大叔阿

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JavaSE 拾遗(7)——JavaSE 多线程

------- android培训、java培训、期待与您交流！ ----------前面的博客主要说了 java 语言的相关内容，下面的博客说 javase 类库框架相关的类容。在 java 语言里面，多线程是用 Thread 类和 Runable 接口来实现的，我认为这个应该不属于基础的语言规则，但是 javase 还是把这两个类放在了 java.lang 包下面，是不是因为所有的编程
复制链接

扫一扫

专栏目录