Java多线程

最新推荐文章于 2023-06-14 17:20:14 发布

J_zyq

最新推荐文章于 2023-06-14 17:20:14 发布

阅读量311

点赞数

分类专栏： Java专栏

本文链接：https://blog.csdn.net/SecienceJohn/article/details/78475670

版权

Java专栏专栏收录该内容

14 篇文章 0 订阅

订阅专栏

多线程作为java中的一个很重要的知识点，所以在学习中有必要总结一下，此篇文章会不多的更新，希望大神可以多多指教

一.线程的生命周期及五种基本状态

关于java中线程的生命周期，先看一下下面这张比较经典的图：

掌握了图中的各个知识点，也就掌握了java的多线程机制，不过我刚开是学习，所以很多都还不是很懂。。。。

通过百度，就简单介绍一下吧：

主要包括：

java线程具有五种基本状态

新建状态（New）：当线程对象创建后，即进入了新建状态，如： Thread t = new MyThread();

就绪装填（Runnable）：当调用线程对象的start()方法，即：t.start()；，线程就进入了就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程就会立即执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程是，此线程才可以真正执行，即进入到运行状态。特别注意的：就绪状态是进入运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用进入到运行状态。根据阻塞原因又可以分为三种：

a. 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

b.同步阻塞：线程在获取synchronized同步锁失败（因为锁被其他线程所占用），它会进入同步阻塞状态；

c.其他阻塞：通过调用线程sleep()或join（）或发出I/O请求时，线程会进入到阻塞状态。当sleep()状态超市，join()等待线程终止或者因异常退出run()方法，该线程结束生命周期。

死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

二.java多线程的创建及启动

java中线程的创建常见的三种基本形式

1.继承Thread类，重写该类的run()方法。

简单的说一下Thread的常用方法：

*start()，启动线程并执行相应的run()方法

* run()，子线程要执行的代码放入run()方法中

*currentThread()，静态的，调用当前的线程

*getName()：获取此线程的名字

*setName()：设置此线程的名字

*yield()：调用此方法的线程释放当前CPU的执行权

*join()：在A线程中调用B线程的join()方法，表示，当执行到此方法，A线程停止，直到B线程执行完毕，A线程再截止join()之后的代码执行

*isAlive()：判断当前线程是否还存活

*sleep(long l)：显示的让当前线程睡眠l毫秒

多线程的创建方式：通过继承的方式

/*
 * 创建一个子线程，完成1-100之间自然数的输出。同样地，主线程执行同样的操作
 * 创建多线程的第一种方式：继承java.lang.Thread类
 */
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
	//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
	public void run(){
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

public class TestThread {
	public static void main(String[] args) {
		//3.创建子类的对象
		SubThread st1 = new SubThread();
		SubThread st2 = new SubThread();

		//4.调用线程的start()：启动此线程；调用相应的run()方法
		//一个线程只能够执行一次start()
		//不能通过Thread实现类对象的run()去启动一个线程
		st1.start();
		
		//st.start();
		//st.run();
		st2.start();
		
		for(int i = 1;i <= 100;i++){
			System.out.println(Thread.currentThread().getName() +":" + i);
		}
	}
}

继承Thread类，通过重写run()方法定义一个新的线程类SubThread，其中的run()方法的方法体代表线程需要完成的任务，称为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start（）方法，使得该线程进入就绪状态，此时线程并不一定会马上执行，这取决与CPU调度时机。

多线程的另一种创建：通过实现的方式

/*
 * 创建多线程方式二：通过实现的方式
 
 */

//1.创建了一个实现了Runnable接口的类

class PrintNum1 implements Runnable{
	//2.实现接口的抽象方法
	public void run() {
		for(int i = 1;i <= 100;i++) {
			if(i % 2 == 0) {
				System.out.println(Thread.currentThread().getName()+ ":" + i);
			}
		}
	}
}
public class TestThread4 {
	public static void main(String[] args) {
		//3.创建一个Runnable接口实现类的对象
		PrintNum1 p = new PrintNum1();
		//p.start();   此时只是实现了一个接口，这个接口只有一个run方法，而start这个方法是没有的
		// p.run();要想启动一个多线程，必须调用start方法；
		//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
		Thread t1 = new Thread(p);
		
		//5.调用start()方法，启动线程并执行run()；
		t1.start();//启动线程，执行Thread对象生成时构造器的形参的对象的run方法
		//在创建一个线程
		Thread t2 = new Thread(p);
		t2.start();
	}
}

两种方式的对比：联系：class Thread implements Runnable
比较哪个好？实现的方式较好。①解决了单继承的局限性。②如果多个线程有共享数据的话，建议使用实现方式，同时，共享
数据所在的类可以作为Runnable接口的实现类。

线程里的常用方法：start() run() currentThread() getName() setName(String name) yield() join() sleep() isAlive()
getPriority() setPriority(int i)； wait() notify() notifyAll()

三.线程的生命周期

四.线程的同步机制（重点、难点）
前提：如果我们创建的多个线程，存在着共享数据，那么就有可能出现线程的安全问题：当其中一个线程操作共享数据时，还未操作完成，
另外的线程就参与进来，导致对共享数据的操作出现问题。
解决方式：要求一个线程操作共享数据时，只有当其完成操作完成共享数据，其它线程才有机会执行共享数据。
方式一：同步代码块：
synchronized(同步监视器){
//操作共享数据的代码
}
注：1.同步监视器：俗称锁，任何一个类的对象都可以才充当锁。要想保证线程的安全，必须要求所有的线程共用同一把锁！
2.使用实现Runnable接口的方式创建多线程的话，同步代码块中的锁，可以考虑是this。如果使用继承Thread类的方式，慎用this!
3.共享数据：多个线程需要共同操作的变量。明确哪部分是操作共享数据的代码。

方式二：同步方法：将操作共享数据的方法声明为synchronized。
比如：public synchronized void show(){ //操作共享数据的代码}
注：1.对于非静态的方法而言，使用同步的话，默认锁为：this。如果使用在继承的方式实现多线程的话，慎用！
2.对于静态的方法，如果使用同步，默认的锁为：当前类本身。以单例的懒汉式为例。 Class clazz = Singleton.class

总结：释放锁:wait();
不释放锁： sleep() yield() suspend() (过时，可能导致死锁)

死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
死锁是我们在使用同步时，需要避免的问题！

五.线程的通信：

如下的三个方法必须使用在同步代码块或同步方法中！
wait():当在同步中，执行到此方法，则此线程“等待”，直至其他线程执行notify()的方法，将其唤醒，唤醒后继续其wait()后的代码
notify()/notifyAll():在同步中，执行到此方法，则唤醒其他的某一个或所有的被wait的线程。
>例题：1.两个线程交替打印1-100自然数 2.生产者、消费者的例子

例子1：

package com.atguigu.java1;
/*线程通信，如下的三个关键字使用的话，都得在同步代码块或同步方法中
 * wait()：一旦一个线程执行到wait()，就释放当前的锁
 * notify()或notifyAll()，唤醒wait的一个或所有的线程
 * 用两个线程交替输出1-100.
 * 
 */

class PrintNum implements Runnable {	
	int  num = 1;
	public void run() {
	
		while (true) {
			synchronized (this) {
				notify();
				if (num <= 100) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + ":" + num);
					num++;
				}
				else {
					break;
				}
				try {
					wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}
public class Testexe {
	public static void main(String[] args) {
		PrintNum p = new PrintNum();
		
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		
		t1.setName("线程1");
		t2.setName("线程2");
		
		t1.start();
		t2.start();
		
		
	}
}

例子2：

package com.atguigu.java1;
/*
 * 生产者/消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员
 * 处取走产品，店员一次只能持有固定数量的产品，如果生产者试图生产更多的产品，店员会叫生产者停一下
 * 如果店中有空位放产品再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下
 * 如果店中有产品了再通知消费者过来取走商品
 * 
 * 
 * 
 * 分析：
 * 1.是否涉及到多线程的问题？   是！ 生产者、消费者
 * 2.是否涉及到共享数据？  是！  考虑线程安全问题
 * 3.此共享数据是谁？   产品的数量
 * 4.是否涉及到线程的通信？   存在着生产者和消费者的通信
 */

class Clerk{
	//创建一个店员，里面的数据是共享数据.
	int producter;
	
	public synchronized void addProducter() {
		if(producter >= 20) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else {
			producter++;
			System.out.println(Thread.currentThread().getName() + ":生产了第" + producter + "个产品");
			notifyAll();
			
		}
		
	}
	public synchronized void reduceProducter() {
		if(producter <= 0 ) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else {
			System.out.println(Thread.currentThread().getName() + ":消费了第" + producter + "个产品");
			producter--;
			notifyAll();
		}
		
	}
}
class Producter implements Runnable{
	//创建一个生产者
	Clerk clerk;
	public Producter(Clerk clerk) {
		this.clerk = clerk;
	}
	public void run() {
		while(true) {
			clerk.addProducter();
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
class Customers implements Runnable{
	
	Clerk clerk;
	public Customers(Clerk clerk) {
		this.clerk = clerk;
	}
	public void run() {
		while(true) {
			clerk.reduceProducter();
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
}
public class TestProduceConsume {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producter p1 = new Producter(clerk);
		Customers c1 = new Customers(clerk);
		
		Thread t1 = new Thread(p1);
		Thread t3 = new Thread(p1);
		Thread t2 = new Thread(c1);
		
		t1.setName("生产者1");
		t3.setName("生产者2");
		t2.setName("消费者1");
		
		t1.start();
		t2.start();
		t3.start();
		
	}
}

J_zyq

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java多线程

多线程作为java中的一个很重要的知识点，所以在学习中有必要总结一下，此篇文章会不多的更新，希望大神可以多多指教一.线程的生命周期及五种基本状态关于java中线程的生命周期，先看一下下面这张比较经典的图：掌握了图中的各个知识点，也就掌握了java的多线程机制，不过我刚开是学习，所以很多都还不是很懂。。。。通过百度，就简单介绍一下吧：主要包括：ja
复制链接

扫一扫