三、多线程

最新推荐文章于 2023-05-04 17:38:53 发布
最新推荐文章于 2023-05-04 17:38:53 发布
阅读量212 收藏
点赞数
分类专栏： 小白 - JAVA基础（初）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45602227/article/details/102405708
版权

线程概念

1.进程与线程
进程：正在执行的程序为一个进程。进程负责了内存的划分。

windows号称多任务的操作系统，那么windows是同时运行多个程序么？
从宏观角度：windows同时执行多个任务。
从微观角度： cpu执行多个进程时，做了快速切换动作，即按照一定的算法切换执行进程。用户察觉不到。与其说是进程做资源抢夺动作，不如说是线程在做资源抢夺。

线程：线程在一个进程中负责代码的执行，即进程中的一个执行路径。

多线程：在一个进程中，有多个线程执行不同的任务。

2.多线程的好处与弊端

多线程的好处：

  • 解决了一个进程可以执行多个任务。
  • 提高了资源利用率

多线程的弊端：

  • 降低一个进程中线程的执行概率
  • 增加了cpu的负担
  • 会引发线程安全问题

线程的创建

方式一：继承Thread类，重写run方法。
方式二：实现Runnable接口，重写run方法。然后将对象传给Thread对象执行。
推荐使用第二种，java只支持单继承，允许多继承。

注意事项：
1.Runnable的实现类是线程对象么？
===》只有Thread或其子类才是线程对象。

2.为什么要把Runnable实现类的对象作为实参传给Thread对象呢？作用是什么》
===》Thread类把Runnable实现类中的run方法作为线程的任务代码来执行。

this和currentThread在下面代码中不是同一个对象。this在代码中指的的Runnale实现类的当前对象。Thread,currentThread（）指的是线程对象。
在这里插入图片描述

线程的生命周期

1。创建（NEW）
创建线程对象后，该对象处于线程的新建状态，JVM只是为其对象分配了对象。没有线程的任何动态性能。

2。可运行状态（Runnable）
线程对象调用start（）方法后，线程就会进入可运行状态。此时获得了CPU的等待资格，但没有获取CPU的执行权，线程能否执行还需要CPU进行资源调度。

3.运行状态（Running）
线程获取CPU的执行权，此时进入运行状态。由于cpu不断做出切换动作，所以，此时线程会在运行状态与可运行状态之间来回切换。

4.阻塞状态(Blocked)
一个正在执行的线程在做耗时的IO流操作、wait（）、sleep（）等阻塞方法时，会进入阻塞状态（Blocked）

-----线程在获取一个对象的同步锁时，如果该锁没有被别的线程释放，则当前线程进入阻塞状态。只有当同步锁被释放后，该线程才会重新进入可运行状态。

-----线程在执行耗时的IO流操作时，会进入阻塞状态。当IO流结果有返回，才会重新进入可运行状态。

-----线程执行Thread.sleep(1000)方法时，会进入阻塞状态。只有当休眠时间结束，才会进入可运行状态。

-----当线程调用了某个对象的wait（）方法时，也会使线程进入阻塞状态，notify（）方法唤醒。

——一个线程调用了另一个线程的join（）方法时，当前线程进入阻塞状态。等新加入的线程运行结束后会结束阻塞状态，进入就绪状态。

线程从阻塞状态只能进入就绪状态，而不能直接进入运行状态，即结束阻塞的线程需要重新进入可运行池中，等待系统的调度。

5.死亡状态（Terminated）
线程的run（）方法正常执行完毕或者线程抛出一个未捕获的异常（Exception）、错误（Error），线程就进入死亡状态。一旦进入死亡状态，线程将不再拥有运行的资格，也不能转换为其他状态。

创建（new） —》可运行状态（Runnable）–》（《–》阻塞状态–》 ）—》 运行状态 （Running） --》死亡状态(Terminated)

在这里插入图片描述

线程常用方法

Thread（String name） 重写Thread的带参构造方法，指定线程名称。

t.setName(String name) 设置线程名称

t.setPriority(int i) 设置线程的优先级，设置数字越大，优先级越高 【1-10】
t.getPriority() 获取线程的优先级。（线程的优先级默认为5）

Thread.sleep(1000) 让线程休眠进入阻塞状态。这个方法由哪一个线程来执行，哪一个线程就休眠。不会释放锁资源

Thread.currentThread() 这个方法由哪一个线程来执行，就返回哪一个线程对象。

public static void main(String[] args) throws IOException, InterruptedException, ParseException {
		
		App2 a=new App2("看片线程");
		a.start();
		System.out.println("看片线程优先级："+a.getPriority());
		
		System.out.println("主线程优先级："+Thread.currentThread().getPriority());

	}

线程安全问题

例子：
三个窗口同时卖票，会出现票据卖出重复问题。
在这里插入图片描述

出现线程安全问题根本的原因：

1.存在多个线程，并且线程之间共享资源。
2.有多个语句操作共享资源

线程安全问题解决方案

sun公司提供线程同步机制解决线程安全问题。
同步机制：

  • 同步代码块
  • 同步方法

同步代码块注意事项：
1.任意一个对象都可以作为锁对象。因为所有对象内部都维护了一个状态位，java同步机制就是使用了对象中的状态位作为锁标识。
2.在同步代码块中调用Thread.sleep（）方法，并不会释放锁资源。【上卫生间关门】
3.同步机制影响执行效率，所以只有在真正线程安全问题下才使用。
4.多线程操作的锁对象必须是唯一共享的。

同步方法注意事项：
静态的同步方法，锁对象是字节码文件。
普通的同步方法，锁对象是this对象。
同步方法的锁是固定的。

总结：
1.同步代码块的锁可以是任意的对象，同步方法的锁是固定的。静态方法的锁对象是字节码文件，普通方法的锁对象是this对象。

2.锁对象必须是线程共享的，否则锁不住。

3.在同步代码块或同步方法中，调用Thread.sleep（）方法，是不会释放锁对象的。调用wait（）方法是会释放锁对象的。

售票问题代码实现：

package com.gupao.demo;

import java.util.concurrent.CountDownLatch;

public class Window  extends Thread{
	
	
	public Window(String name) {
		super(name);
	}
	
	public static int tick_num=50;
	
	@Override
	public void run() {
		while(true) {
				
			synchronized ("锁") {
				
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				if(tick_num>0) {
					tick_num--;
					System.out.println(Thread.currentThread().getName()+"卖出一张票，还剩："+tick_num);					
				}else {
					System.out.println("没票了");
					return;
				}
			
			 }		
	}
	
	public static void main(String[] args) {		
		Window a1=new Window("窗口1");
		Window a2=new Window("窗口2");
		Window a3=new Window("窗口3");
		
		a1.start();
		a2.start();
		a3.start();
	}
}

死锁

线程同步机制引发了死锁问题。

死锁问题出现的根本原因：
存在两个或两个以上的线程
存在两个或两个以上的共享资源

死锁问题的解决方案： 没有方案，只能尽量的去避免

代码模拟问题：
张三李四都去争抢遥控器和电池

public class App2  extends Thread{
	
	public App2(String name) {
		super(name);
	}
	
	
	
	@Override
	public void run() {
		if("张三".equals(this.getName())) {
			synchronized ("电池") {
				System.out.println("张三拿到了电池，准备去拿遥控器");
				synchronized ("遥控器") {
					System.out.println("张三拿到了电池和遥控器");
				}
				
			}
		}
		
		if("李四".equals(this.getName())) {
			synchronized ("遥控器") {
				System.out.println("李四拿到了遥控器，准备去拿电池");
				synchronized ("电池") {
					System.out.println("李四拿到了电池和遥控器");
				}
				
			}
		}
	}



	public static void main(String[] args) throws IOException, InterruptedException, ParseException {
		App2 a=new App2("张三");
		App2 a2=new App2("李四");

		a.start();
		a2.start();
		
	}
	

}

线程通信

wait（）
一个线程执行wait方法，那么该线程会进入以锁对象为标识符的的线程池中。并且会释放锁资源

notify()
唤醒线程池中任何一个线程，那么该线程会唤醒以锁对象为标识符的线程池中的任意一个线程。

notifyAll（），唤醒锁对象中所有的线程。

注意事项：
wait和notify方法是属于Object对象的。
wait与notify方法必须在同步代码块或同步方法中使用。
wait和notiry必须由锁对象进行调用。

生产者生产产品，消费者去消费
代码实现：

public class Product {
	String name;
	double price;
	
	public static void main(String[] args) {
		Product t=new Product();
		
		Customer c=new Customer(t);
		Producter p=new Producter(t);
		c.start();
		p.start();
		
	}
}

//生产者
class Producter extends Thread{
	
	Product p;
	
	public Producter(Product p) {
		super();
		this.p = p;
	}
	@Override
	public void run() {
		
		int i=0;
		while(true) {
			synchronized (p) {
				if(i%2==0) {
					p.name="苹果";
					p.price=12;
				}
				if(i%2!=0) {
					p.name="香蕉";
					p.price=5;
				}
				i++;
				System.out.println("生产者生产了"+p.name +",价格为"+p.price+"钱");
				try {
					p.notify();
					p.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
}

//消费者
class Customer extends Thread{
		Product p;
	
		
		public Customer(Product p) {
			super();
			this.p = p;
		}



		@Override
		public void run() {
			while(true) {
				 synchronized (p) {
					 System.out.println("消费者买了"+p.name+",花了"+p.price+"钱");
					 try {
						p.notify();
						p.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				 }
			}
		}
		
		
}

停止线程

t.stop() 停止线程，该方法已经过时，不安全的方法。
t.interrupt（） 唤醒线程池中的线程，并且线程会接收到一个InterruptException 异常。

线程的停止：
停止一个线程一般通过变量去控制。
如果要停止一个阻塞状态的线程，还要使用变量配合notify（）或interrupt（）方法来控制。

package com.gupao.demo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

public class Demo  implements Runnable{

	boolean flag=true;
	@Override
	public synchronized void run() {
		int i=0;
		while(flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				System.out.println(e);
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
			i++;
		}
		
		
	}
	 
	
	
	public static void main(String[] args) {
		Demo r=new Demo();
		
		Thread t=new Thread(r,"线程1");
		
		t.start();
		
		for(int i=0;i<1000000;i++) {
			if(i==100000) {
				r.flag=false;
				//方式一：使用notify，必须在同步方法中由锁对象调用
//				synchronized (r) {
//					r.notify();
//				}
				
				//方式二：使用interrupt
				t.interrupt();
			}
			
		}
		
	
}

守护线程
守护线程（后台线程）：在一个进程中，如果只剩下守护线程，那么守护线程也会死亡。

t.setDaemon(true) 设置该线程为守护线程。然后调用start（）开启线程。【设置守护线程动作必须在start方法之前】

t.setDaemon(true)
t.start() 先设置守护标志，在开启

开启主线程和守护线程，此时JVM中自定义线程之后主线程和守护线程，当主线程执行完毕就会销毁，此时只剩下守护线程，然后守护线程也会死亡。

package com.gupao.demo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

public class Demo  extends  Thread{
	
	@Override
	public void run() {
		while(true) {
			System.out.println(Thread.currentThread().getName());
		}
	}
	
	public static void main(String[] args) {
		
		Demo d=new Demo();
		d.setDaemon(true);

		d.start();
	
		
		for(int i=0;i<10000;i++) {
			System.out.println(Thread.currentThread().getName());
		}
		
	}
	
}

join线程
t2.join（） 加入。一个线程执行该方法，那么就会有的线程加入。执行该语句的线程必须先让给新的线程执行。新的线程执行完毕才能继续执行。【线程让步】

t2.start（）；
t2.join(); //先开启线程在加入线程

package com.gupao.demo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;


public class App6{
	
	 
	 public static void main(String[] args) {
		
		 Mother m=new Mother();
		 m.start();
		 
	}
}

class Mother extends  Thread{
	
	@Override
	public void run() {
		System.out.println("老妈做饭");
		System.out.println("老妈发现没有酱油，通知儿子下楼买酱油");
		
		try {
			Son  s=new Son();
			s.start();
			
			s.join();
			
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("老妈得到酱油，继续做饭");	
		System.out.println("香喷喷的饭来了。。。");	

	}
	
}
 class Son  extends  Thread{
	
	@Override
	public void run() {
		System.out.println("儿子下楼");
		System.out.println("儿子买酱油");
		System.out.println("儿子买完酱油，儿子上楼");		
	}
	
}

控制台打印：

老妈做饭
老妈发现没有酱油，通知儿子下楼买酱油
儿子下楼
儿子买酱油
儿子买完酱油，儿子上楼
老妈得到酱油，继续做饭
香喷喷的饭来了。。。
二旬、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对于为什么线程在io操作时需要阻塞的一些理解
m0_49908016的博客
10-01 2278
为什么线程在io操作时需要阻塞呢，根本原因应该是CPU的运行速度要远超过一个io的速度，CPU不可能去等待一个要很久才能完成的io操作，所以就是当进行io操作时线程需要进入一个阻塞状态（当然，异步io的话是线程也不去等待io了，当数据准备好的时候来通知线程就好了，此处讨论阻塞io），当数据准备好了之后，才会再次进入一个CPU运行队列执行接下来的操作。 为什么io的操作CPU只需要下一个指令，而不是要全程等着呢（这是我的一些理解，仅用于自己笔记，可能会有错误，也希望大家指正）我的理解是CPU就像是我们的大脑，
操作系统--进程调度（运行、阻塞、就绪）
qq_42824842的博客
08-28 6409
进程调度：四种进程间的状态转换：就绪—>运行运行—>阻塞阻塞—>就绪运行—>就绪1）进程的三种基本状态进程在运行中不断地改变其运行状态。
Linux内核：进程管理——进程状态及转换
最新发布
m0_74282605的博客
05-04 651
主要有两种情况会发生这种挂起状态的变化：①若当前不存在活动就绪进程，则至少有一个活动阻塞进程使其变为静止阻塞进程，以腾出内存空间，从外存调入一个静止就绪进程使其变为活动就绪进程（保证内存中至少有一个活动就绪进程，避免CPU空闲）；当需要创建一个新进程时，系统为该进程分配一个进程控制块（PCB），并为该进程分配内存空间，且装入该进程对应的程序和有关数据。由于阻塞进程阻塞原因被解除后，就满足就绪状态的条件，故只能先变迁到就绪状态中。当一个进程生成另一个进程时，生成进程称为父进程，而被生成的进程陈各位子进程。
线程（一）
weixin_49690872的博客
03-15 864
线程是CPU使用的基本单位，它由线程ID、程序计数器、寄存器集合和栈组成。 多核编程 并发(Concurrency):指能够交替执行不同的任务，单处理器/核心，CPU调度器通过上下文切换提供并发性 并行(Parallelism):指能够同时执行不同的任务，需要多个处理器/内核 并行意味着并发，但并发并不意味着并行 并行类型 数据并行(data parallelism)：不同的数据输入以并行方式运行同一个函数。将可以解决问题的数据进行分割，将分割好的数据放在一个或者多个核上进行执行，每一个核对这些数据都进行类
线程——运行和阻塞状态详解
sunyuxiu的博客
06-28 3255
线程——运行和阻塞状态详解 所有现代的桌面和服务器操作系统都采用抢占式调度策略，但一些小型设备如手机等可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃其所占用的资源——也就是必须有线程主动放弃其所占用的资源。 当发生如下情况时，线程将进入阻塞状态： 1、线程调用了sleep()方法主动放弃其所占用的处理器资源； 2、线程调用了一个阻塞式I...
c语言多进程多线程编程
07-21
在计算机科学中，多进程和多线程是两种并发执行的方式，它们允许程序在同一时间处理多个任务，从而提高系统的效率和响应性。C语言作为一门底层且强大的编程语言，提供了丰富的系统调用接口来实现多进程和多线程编程...
多线程 hbase
03-03
三、示例：多线程HBase写入 创建一个线程池，每个任务负责写入一批记录到HBase。每个任务先构建`Put`对象，然后在主线程中提交到`HTable`，以批量写入的方式提高效率。同时，确保每个线程在执行写入前获取`HTable`的...
java 多线程
11-07
Java中可以通过以下三种方式实现多线程： 1. **继承Thread类**：通过继承`Thread`类来创建自定义线程类，并重写`run()`方法，在其中编写线程执行的代码。 2. **实现Runnable接口**：实现`Runnable`接口的`run()`...
JAVA多线程JAVA多线程
02-14
线程优先级也是Java多线程中的一个特性，每个线程都有一个优先级，Java中定义了三个预定义的优先级：Thread.MIN_PRIORITY（1）、Thread.NORM_PRIORITY（5）和Thread.MAX_PRIORITY（10）。然而，优先级并不保证线程的...
多线程Demo
11-27
三、多线程同步与通信 1. **synchronized关键字**：用于保证同一时间只有一个线程访问共享资源，防止数据不一致。 2. **wait()与notify()**：这两个方法用于线程间的通信，一个线程调用`wait()`会释放锁并进入等待...
线程五种状态(新建、就绪、运行、阻塞、死亡)
热门推荐
坚持
01-06 3万+
线程的5种状态：  每个 Java 程序都有一个缺省的主线程，对于 Java 应用程序，主线程是 main()方法执行的线索； 对于 Applet 程序，主线程是指挥浏览器加载并执行 Java Applet 程序的线索。要想实现多线程， 必须在主线程中创建新的线程对象。任何线程一般具有五种状态，即创建、就绪、运行、阻塞、终止。 1、新生状态        在程序中用构造方法（new操...
进程调度（执行，阻塞，就绪）
qq_40385194的博客
02-13 1万+
进程调度：四种进程间的状态转换： 就绪—&gt;执行 执行—&gt;阻塞 阻塞—&gt;就绪 执行—&gt;就绪1）进程的三种基本状态进程在运行中不断地改变其运行状态。通常，一个进程必须具有以下三种基本状态：就绪状态： 当进程已分配到除CPU以外的所有必要的资源，只要获得处理机便可立即执行，这时的进程状态就称为就绪状态；执行状态：当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状...
线程的就绪、运行、阻塞
Wit_tang的博客
05-18 6691
就绪->运行：调度器选择该线程执行 运行->就绪：该线程时间片用完 就绪队列里面的线程就是在等待时间片，如果时间片轮到自己，就占用CPU；相对的是block队列，里面的线程即使有空闲的CPU也不会分配给它，因为阻塞线程是被外部其他事件所阻塞，比如等待共享锁的释放。 技术上处于等待池和锁定池中的线程都是传统意义上的阻塞状态，只不过为不同的对象所阻塞而已。
为什么wait,notify和notifyAll要与synchronized一起使用？
Crazy.Mark
02-09 8776
Object.wait(),Object.notify(),Object.notifyAll()都是Object的方法，换句话说，就是每个类里面都有这些方法。 Object.wait()：释放当前对象锁，并进入阻塞队列 Object.notify()：唤醒当前对象阻塞队列里的任一线程（并不保证唤醒哪一个） Object.notifyAll()：唤醒当前对象阻塞队列里的所有线程 为什么这三个...
线程的几种可运行状态
banyangjia7103的博客
10-29 376
线程在执行过程中，可以处于下面几种状态：1、就绪(Runnable):线程准备运行，不一定立马就能开始执行。2、运行中(Running)：进程正在执行线程的代码。3、等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。4、睡眠中(Sleeping)：线程被强制睡眠。5、I/O阻塞(BlockedonI/O)：等待I/O操作完成。6、同步阻塞(BlockedonSynch...
Java入门——（4）多线程
weixin_30314631的博客
06-30 140
关键词：线程、Thread、Runnable、sleep()、yield()、join()、同步 一、线程的概述 在一个操作系统中，每个独立执行的程序都可以称为一个进程，也就是“正在运行的程 序”。而在进程中还可以有多个执行单元同时执行，这些执行单元可以看作程序执行的一条 条线索，被称为线程。Java 运行环境是一个包含了不同的类和程序的单一进程。线程可以...
操作系统复习笔记(1)-进程与线程
qq_40626141的博客
06-04 525
进程 写在前面 本系列是操作系统期末复习笔记，主要参考资料是王道《2019年操作系统考研复习指导》与《操作系统-精髓与设计原理：第七版》。    本文是本系列的第一篇，介绍进程与线程，是操作系统中的重中之中。对应《操作系统精髓》的第三章与第四章。 进程的定义 Q1：进程和程序是两个概念：程序是代码+数据，进程是代码+数据+堆栈+PCB；程序是永存、静态的，进程是暂时的、动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值