Java-多线程

最新推荐文章于 2024-02-19 14:45:43 发布
最新推荐文章于 2024-02-19 14:45:43 发布
阅读量249 收藏
点赞数
分类专栏： Java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46859537/article/details/106192619
版权

一 、线程相关知识

1、概述

首先我们来认识一下什么是程序、进程；

程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码；

进程(process)：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域；

线程

线程(thread)：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小；

在这里插入图片描述
Java程序的内存结构：

在这里插入图片描述

  • 一个进程可以有多个线程，每个线程都拥有自己独立的虚拟机栈、程序计数器；并且他们共享同一个进程中的结构：方法区、堆。

那如果多个线程都要使用共享的相同数据，会有什么问题呢？

2、 单核CPU和多核CPU

  • 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。涉及到CPU处理线程的方式，CPU在单位时间（也就是说一个时间片内）内只能处理一个线程，于是就将其他的线程设置为阻塞状态，加入到阻塞队列中，等到处理完成当前线程后从就绪队列中取出新的线程进行处理，由于切换和处理时间很快用户感知不到于是用户便认为CPU在同一时间内处理多个线程；
  • 多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）；
  • 一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程；

程序执行过程能用一条线画出来的，就是一条路径，一个线程；

3、并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事；

并发：一个CPU(采用时间片)同时执行多个任务（实际不是真正意义上的同时）。比如：秒杀、多个人做同一件事；

4、多线程程序的优点

  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验；
  2. 提高计算机系统CPU的利用率；
  3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改；

【使用场景】

  1. 程序需要同时执行两个或多个任务；
  2. 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等；
  3. 需要一些后台运行的程序时；

二、Thread类

1、java. lang.Thread类

Java语言的JVM允许程序运行多个线程，它通过 java. lang.Thread类来体现；每个线程都是通过某个特定 Thread对象的run()方法来完成操作的(方法体可以说是线程体)；通过该 Thread对象的 start()方法来启动这个线程，而非直接调用run()；【回调方法】

2、Thread类的常用方法

  1. start():启动当前线程；调用当前线程的run()，只有Thread类和他的子类才能调用start()方法；
  2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中；
  3. currentThread():静态方法，返回执行当前代码的线程；
String threaName = Thread.currentThread().getName();

  1. getName():获取当前线程的名字；

  2. setName():设置当前线程的名字；

  3. yield():释放当前cpu的执行权；

//重写的run()方法；
public void run() {
		for (int i = 0; i < 100; i++) {
			if (i==6){
                //当 i=6,释放cpu执行权，但还是有概率继续执行该线程；
				yield();    //静态方法；
			}
  1. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态；
//在主线程中调用testThread对象（另一个线程对象）的join;
if (i==20){
    try {
        testThread.join();    //join方法
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

  1. stop():该方法已过时。当执行此方法时，强制结束当前线程；

  2. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态；

if (i%2==0){
    try {
        sleep(1000); //阻塞1000ms，也就是1s;
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
  1. isAlive():判断当前线程是否存活；
//testThread是一个线程对象，该方法返回一个boolean值；
System.out.println(testThread.isAlive());

3、Thread类的构造方法

  • Thread()：创建新的 Thread对象；
  • Thread（String threadName）：创建线程并指定线程实例名；
  • Thread（Runnable target）：指定创建线程的目标对象，它实现了 Runnable接口中的run方法；
  • Thread（Runnable target， String name）：创建新的 Thread对象；

4、优先级

1、线程的优先级实际是Threa类定义的三个常量

  • MAX_PRIORITY：10 //最高
  • MIN _PRIORITY：1 //最低
  • NORM_PRIORITY：5 -->默认优先级

2、获取和设置当前线程的优先级

  • getPriority():获取线程的优先级
  • setPriority(int p):设置线程的优先级
//设置最高优先级
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

【注意：高优先级只是先执行的概率较高，并不是一定就是先执行 】

5、生命周期

Thread类的五个状态：

  • 新建：当一个 Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态；
  • 就绪：处于新建状态的线程被star()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源；
  • 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能；
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CP∪并临时中止自己的执行，进入阻塞状态；
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束；

在这里插入图片描述

三、创建线程的方式

1、继承Thread类的方式

  1. 创建一个继承于Thread类的子类；
  2. 重写Thread类的run() → 将此线程执行的操作声明在run()中；
  3. 创建Thread类的子类的对象；
  4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()；

【代码例子】

public static void main(String[] args) {
    //Thread的匿名内部子类，重写run()方法；
    new Thread(){
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if (i % 2 == 0) {
                    //Thread.currentThread().getName() 显示线程名
                    System.out.println(Thread.currentThread().getName()+ ":" + i);
                }
            }
        }
    }.start();

    new Thread(){
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if (i % 2 != 0) {
                    System.out.println(Thread.currentThread().getName()+ ":" + i);
                }
            }
        }
    }.start();

    for (int i = 0; i < 50; i++) {
        System.out.println(Thread.currentThread().getName()+":"+"主线程执行中...");
    }
}

//部分输出结果
Thread-0:56
Thread-1:1
Thread-1:3
Thread-1:5
Thread-1:7
Thread-0:58
main:主线程执行中...
main:主线程执行中...
  • 查看输出结果可知，主线程和两个分线程是交替执行的；

【注意】

1、一个线程对象只能调用一次start()方法，否则会抛出 IllegalThreadStateException 非法线程状态异常；

2、run()方法是对象调用start()方法后，由jvm调用，调用时间是cpu调度决定的；

3、如果直接调用run()方法，则不会启动多线程，属于主线程；

4、创建多个线程就要创建多个Thread子类的线程对象；

2、实现Runnable接口的方式

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

【代码例子】

//创建一个实现了Runnable接口的类；
class MThread implements Runnable{
    //实现类去实现Runnable中的抽象方法：run()；
   @Override
   public void run() {
      for (int i = 0; i < 100; i++) {
         if (i % 2 ==0){
            System.out.println(Thread.currentThread().getName()+":"+i);
         }
      }
   }
}

public class ThreadTest1 {
   public static void main(String[] args) {
       //创建实现类的对象；
      MThread mThread = new MThread();
      //将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象；
      Thread t1 = new Thread(mThread);
      Thread t2 = new Thread(mThread);
      t1.setName("线程一");
      t2.setName("线程二");
       //通过Thread类的对象调用start()；
      t1.start();
      t2.start();
   }
}

【两种方式的对比】

  • 相同点

两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。 目前两种方式，要想启动线程，都是调用的Thread类中的start()；

  • 通过继承Thread类，有单继承性的局限性；
  • 通过实现Runnable的方式，更适合来处理多个线程共享数据的情况；
  • 实际上，Thread类也实现了Runnable；
public class Thread implements Runnable

3、实现Callable接口的方式

  1. 创建一个实现Callable的实现类；
  2. 实现call方法，将此线程需要执行的操作声明在call()中；
  3. 创建Callable接口实现类的对象；
  4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象；
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()；
  6. 获取Callable中call方法的返回值；（返回值不获取，不影响）

【代码例子】

//创建一个实现Callable的实现类
class NumThread implements Callable{
	//实现call方法,将此线程需要执行的操作声明在call()中
	@Override
	public Object call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			if (i%2 == 0){
				System.out.println(i);
				sum += i;
			}
		}
		return sum; //int自动装箱Integer，赋值给Object
	}
}

public class ThreadNew {
	public static void main(String[] args) {
        //创建Callable接口实现类的对象
		NumThread numThread = new NumThread();
		//将此Callable接口实现类的对象作为传递FutureTask构造器中，创建FutureTask的对象
		FutureTask futureTask = new FutureTask(numThread);
		
		new Thread(futureTask).start();
		
		try {
			//get()返回值即为FutrueTask构造器参数Callable实现类重写的call()的返回值;
			Object sum = futureTask.get();
			System.out.println("总和为："+sum);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}

【优点】

  1. call()可以返回值的；
  2. call()可以抛出异常，被外面的操作捕获，获取异常的信息；
  3. Callable是支持泛型的；

4、使用线程池的方式

经常创建和销毁、使用量特别大的资源，比如并发情况下的线程对性能影响很大。提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具；

【ExecutorService和 Executors】

JDK 5.0起提供了线程池相关API，ExecutorService和 Executors工具类、工厂类；

  • ExecutorService：真正的线程池接口。常见子类 ThreadPoolexecutor ;

    • void execute(Runnable command）：执行任务/命令，没有返回值，一般用来执行Runnable ；
    • Future submit（Callabletask）：执行任务，有返回值，一般又来执行Callable ;
    • void shutdown()：关闭连接池 ;

  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池 ;

    • Executors. newCachedThreadPool()：创建一个可根据需要创建新线程的线程池 ;

    • Executors.newFⅸedthreadPool(n)；创建一个可重用固定线程数的线程池 ;

    • EXecutors. newSingleThreadEXecutor()：创建一个只有一个线程的线程池 ;

    • Executors. new thread Poo(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行;

【子类ThreadPoolExecutor部分属性说明】

  1. corePoolSize：核心池的大小

  2. maximumPoolSize：最大线程数

  3. keepAliveTime：线程没任务时最多保持多长时间后会终止

【使用线程池的方式的实现步骤】

  1. 提供指定线程数量的线程池；
  2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象；
  3. 关闭连接池；

【代码例子】

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) {
        //提供指定线程数量的线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
        
		ThreadPoolExecutor poolExecutor = (ThreadPoolExecutor) service; //向下转型，调用子类的属性；
		//设置线程池的属性,管理线程
//		poolExecutor.setCorePoolSize(15);
//		poolExecutor.setKeepAliveTime();
		//获取service的类
//		System.out.println(service.getClass());
        
		//执行指定的线程的操作
		service.execute(new NumberThread()); //适合使用于Runnable
		service.execute(new NumberThread1()); //适合使用于Runnable
//		service.submit(Callable callable); //适合使用于Callable
		
		service.shutdown(); //关闭线程池
	}
}

【优点】

  1. 提高响应速度（减少了创建新线程的时间）；
  2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）；
  3. 便于线程管理；

【总结】

Java中多线程的创建有几种方式？四种。

JDK 5.0以前：

  • 即继承Thread类重run方法；
  • 实现Runnable接口实现run方法；

JDK 5.0以后：

  • 实现callable接口，实现call方法；
  • 利用线程池；

四、线程同步

当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态；

1、同步的原因

我们以一个卖票例子来说明；假如现在有多个窗口卖票，总票数为100张；

  • 问题：卖票过程中，出现了重票、错票 → 出现了线程的安全问题；
  • 问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票；
  • 如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变；

【这个时候就需要java的线程同步了，实际就是把共享数据上锁，上锁后别的线程进不来，独自操作的时候就是单线程】

2、同步的方式

2.1 同步代码块

synchronized(同步监视器){//同步监视器就是需要同步线程的公共对象
   //需要被同步的代码
}
  • 实现Runnable方式的线程中的同步代码块
class Window1 implements Runnable{
	private int ticket = 100;
	Object obj = new Object(); //创建一个同步监视器，或者直接this
	@Override
	public void run() {
		while (true) {
   			//以关键字synchronized包围的共享数据，用一个任意对象（即同步监视器）上锁
			synchronized (obj) {
				if (ticket > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread()
							.getName() + ":卖票，票号为：" + ticket);
					ticket--;
				} else {
					break;
				}
			}
		}
	}
}

public class WindowTest1 {
	public static void main(String[] args) {
		Window1 w = new Window1();
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		t1.start();
		t2.start();
		t3.start();
	}
}
  • 继承Thread方式的线程中的同步代码块
class Window2 extends Thread{
	
	private static int ticket = 100;
	
    //static保证是唯一的锁
	private static Object obj = new Object();
	
	@Override
	public void run() {
		while (true){
			synchronized (obj) {
				if (ticket > 0){
                    //sleep在未同步前增加了错误的概率；方便观察
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(getName()+":卖票，票号为："+ticket);
					ticket--;
				}else {
					break;
				}
			}
		}
	}
}

public class WindowTest2 {
	public static void main(String[] args) {
		Window2 t1 = new Window2();
		Window2 t2 = new Window2();
		Window2 t3 = new Window2();
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		t1.start();
		t2.start();
		t3.start();
				
	}
}

2.2 同步方法

  • 把共享数据放在声明 synchronized 的方法中；
public synchronized void show(){
....
}
  • 将上述代码例子的共享数据抽取出来，然后再需要的地方调用该方法；
 //声明static的同步方法，同步监视器是Window4.class；
private static synchronized  void show(){

		if (ticket > 0){
		System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
			ticket--;
		}
	}

//该同步方法的同步监视器是 this ;再实现接口方式的创建的线程，可以使用这种方法；如果是继承Threa类创建的线程，如果有多个线程对象，每个this都会不一样，这样就不满足锁唯一的条件了；
private synchronized  void show(){

【synchronized的锁】

  1. 任意对象都可以作为同步监视器（锁）；多个线程操作共享数据使用的锁需要是相同的；
  2. 同步方法的锁：静态方法（类名.class）、非静态方法（this）；
private static synchronized  void show(){  //同步监视器是类名.class

private synchronized  void show(){  //同步监视器this
  1. 同步代码块：可以任意指定一个对象作为锁，可以指定为this或类名.class；
synchronized (obj) {  //操作共享数据 }

2.3 Lock锁

【概述】

  • 从JDK 5.0开始，Java提供了更强大的线程同步机制–通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当；
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象；
  • ReentrantLock类实现了Lock，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 Reentrantlock，可以显式加锁、释放锁；

【执行步骤】

  1. 实例化ReentrantLock对象；

  2. 调用lock()，加锁；

  3. 调用unlock()，解锁；

【代码例子】

class TicketTest implements Runnable{
	
	private int ticket =100;
	
	//1、实例化ReentrantLock（使用继承Thread类的方式时，需要声明为static，保证锁的唯一）
	private ReentrantLock lock = new ReentrantLock(true);
	
	@Override
	public void run() {
		while (true){
			try {
				
				//2、调用Lock()
				lock.lock();
				
				if (ticket>0){
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread()
							.getName()+"：售票，票号为："+ticket);
					ticket--;
				}else {
					break;
				}
			} finally {
				//3、调用解锁方法unlock()
				lock.unlock();
			}
		}
	}
}

public class LockTest {
	public static void main(String[] args) {
		TicketTest ticketTest = new TicketTest();
		Thread t1 = new Thread(ticketTest);
		Thread t2 = new Thread(ticketTest);
		Thread t3 = new Thread(ticketTest);
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3  ");
		
		t1.start();
		t2.start();
		t3.start();
	}
}

【synchronized 与 Lock】

  1. 相同：二者都可以解决线程安全问题；

  2. 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器；

  3. Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）；

  4. 建议使用的优先顺序：

    Lock → 同步代码块（已经进入了方法体，分配了相应资源 ) → 同步方法（在方法体之外)；

  5. 利弊： 同步的方式，解决了线程的安全问题。然而，操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低；

【总结】

利用同步锁的方式解决线程安全问题，有三种方式：同步代码块、同步方法和用lock方法；

  1. 必须确保使用同一个资源的多个线程共用一把锁，否则就无法保证共享资源的安全；
  2. 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）；
  3. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明；
  4. 非静态的同步方法，同步监视器是：this；
  5. 静态的同步方法，同步监视器是：当前类本身；

3、同步的使用

  • 查看代码是否存在线程安全

    1. 明确哪些代码是多线程运行的代码；
    2. 明确多个线程是否有共享数据；
    3. 明确多线程运行代码中是否有多条语句操作共享数据；

  • 解决线程安全

    • 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行；
    • 操作共享数据的语句都要放在同步范围中；
    • 注意范围的取值。范围太小，没锁住所有有安全问题的代码 ；范围太大：没发挥多线程的功能；（变成了单线程）

3.1 懒汉式单例模式

使用同步机制将单例模式中的懒汉式改写为线程安全的；

【代码例子】

//懒汉式单例模式
class Bank{
	
	private Bank(){}  //私有构造，外部无法实例化
	
	private static Bank instance = null;
	
	//假如多个线程各自的run()方法中都调用getInstance()方法，这时有线程安全问题
	public static  Bank getInstance(){ //锁是当前类本身
		//共享数据
		//方式一：效率稍差，即使new了实例，线程也要等待别的线程判断结束
//		synchronized (Bank.class) {
//			if (instance == null){
//				instance = new Bank();
//			}
//		}
//		return instance;
		
		// 方式二：效率高，并发判断；
		if (instance == null){
			synchronized (Bank.class) {
				instance = new Bank();
			}
		}
		return instance;
	}
}

3.2 死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁；

【注意】

  • 出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续；
  • 我们使用同步时，要避免出现死锁；

【代码例子】

public class ThreadTest {
   public static void main(String[] args) {
      
      StringBuffer s1 = new StringBuffer();
      StringBuffer s2 = new StringBuffer();
      
      new Thread(){
         @Override
         public void run() {
             //拿了锁s1
            synchronized (s1){
               s1.append("a");
               s2.append("1");
               
               try {
                  Thread.sleep(100);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
               
            	//锁s2
               synchronized (s2) {
                  s1.append("b");
                  s2.append("2");
                  
                  System.out.println(s1);
                  System.out.println(s2);
               }
            }
         }
      }.start();
      
      new Thread(new Runnable() {
         @Override
         public void run() {
             //拿了锁s2
            synchronized (s2){
               s1.append("c");
               s2.append("3");
               
               try {
                  Thread.sleep(100);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
               //锁s1
               synchronized (s1) {
                  s1.append("d");
                  s2.append("4");
                  
                  System.out.println(s1);
                  System.out.println(s2);
               }
            }
         }
      }).start();
   }
}
  • 上述例子中，如果第一个线程拿了锁s1,第二个线程拿了锁s2,此时大家

都在等待对方的锁释放出来，才能继续执行；这个时候陷入了死锁状态；

五、线程通讯

利用线程通讯，可以有效解决线程的死锁问题；

【涉及的Object类的方法】

  • wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器；
  • notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个；如果优先级都相同，则随机唤醒一个；
  • notifyAll():一旦执行此方法，就会唤醒所有被wait的线程；

【代码例子】

//使用两个线程交替打印 1-100；
class Number implements Runnable{
	
	private int number = 1;
	
	@Override
	public void run() {
		while (true){
			synchronized (this) {
				
				//释放阻塞的线程
				notify();
				if (number < 100){
					System.out.println(Thread.currentThread().getName()+":"+number);
					number++;
					try {
						//使线程阻塞
						wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}else {
					break;
				}
			}
		}
	}
}

public class CommunicationTest {
	public static void main(String[] args) {
		Number number = new Number();
		Thread t1 = new Thread(number);
		Thread t2 = new Thread(number);
		
		t1.setName("线程1");
		t2.setName("线程2");
		
		t1.start();
		t2.start();
		
	}
}
  • 假如线程1先抢占了资源，执行了number++后执行wait()，释放锁资源并且进入阻塞状态，线程2获取资源后执行 notify() 释放一个阻塞的线程（只有线程1），线程2执行了number++后执行wait()，释放锁资源并且进入阻塞状态；这样开始了交替打印；

【sleep() 和 wait()】

  • 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态；

  • 不同点：

    1. 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()；
    2. 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中；
    3. 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁；
古希腊雕塑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA-多线程 所有文件
01-09
JAVA-多线程 所有文件
劲爆，Java 协程要来了。。。
Java技术栈，分享最主流的Java技术
12-09 2146
大家好，我是栈长！ 我们都知道，Java 目前最小的系统调度单元只支持线程，官方是不支持协程的，但可以通过第三方框架实现，估计也很少有人会用吧，多线程就能满足需求。 好消息来了，不久的将来，Java 要开始支持协程了，这真是劲爆消息啊！！ 在 openjdk 的官网上，2021/11/15 这天创建了一个新的特性： JEP draft: Virtual Threads (Preview) 虚拟线程，我们来看看是什么鬼： 虚拟线程是一种成本低廉、轻量级的用户模式的线程实现，它可以充分利用可用硬件，大幅减少
探究Java协程的实现原理：从内部机制到应用实践
grandachn的博客
04-13 2603
随着计算机性能的不断提升，应用程序的并发处理需求也越来越大。传统的线程模型虽然能够解决并发编程问题，但是线程的创建和切换成本较高，容易导致系统资源的浪费和性能的下降。Java协程（Coroutine）则是一种更加高效的异步编程方式，它可以轻松地实现并发编程，并且相比于传统的线程模型，具有更加高效的性能和更加优雅的编程方式。本文将详细介绍Java协程的概念、优势以及实现方式。
Java17-20新特性
杀神lwz的博客
11-02 700
Java17是一个LTS(long term support)长期支持的版本，根据计划来看会支持到2029年(java8会支持到2030年)，同时Oracle提议下一个LTS版本是java21，在2023年9月发布，这样将LTS版本的发布周期由之前的3年变为了2年。Java版本支持时间。
Java 协程终于要来了
jjc4261的博客
07-30 905
从 JDK 19 的概述页面来看，JDK 19 处于 Rampdown Phase Two 阶段，整个功能集已被冻结，将不再对 JEP 进行改动。Java 19 只有 7 个新特性：下面对新特性作简短的介绍：记录模式 （预览版）使用 记录模式 增强 Java 编程语言以解构记录值，可以嵌套记录模式和类型模式，实现强大的、声明性的和可组合的数据导航和处理形式。这是一个预览语言功能。另外，最新面试题整理好了，大家可以在小程序在线刷题。Linux/RISC-V 移植将 JDK 移植到 Linux/RISC-V，目
JDK1.8之后的版本变更
px的博客
02-19 973
在2011年JDK1.7版本发布，因其引入了许多新功能、改进和性能优化，大行其道；直至2014年JDK 1.8 版本开启了Lambda表达式实现函数式编程，引入Stream API，新的日期和时间API等特性，使Java编程语言更加现代化，也提供了更多的工具和语言特性，让java 开发者开启了更加简洁的代码编写风格，使得这一个稳定版本得到了广大开发者的喜爱，即使当前JDK版本发布到21，但是1.8任然是大部分程序员的最爱。
java-多线程 test
06-11
java-多线程 test
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
Java-多线程连接池模型
07-22
多线程连接池模型
java-多线程学习代码.zip
10-19
多线程的学习的笔记 Thread1:继承Thread类 * Thread2:继承Runnable接口 * * ThreadMethod：一些Thread常见方法 * ThreadTestDome1 练习：创建两个线程 其中一个线程遍历100以内的偶数 另一个遍历一百内奇数 ...
Java-多线程异步请求统一响应结果.docx
最新发布
04-08
Java-多线程异步请求统一响应结果 多线程异步请求是指在多个线程同时发起请求，并且在请求过程中不阻塞主线程的执行。这样可以提高程序的并发能力和响应速度。 需要注意的是，在实际的异步请求中，可能需要使用...
java-multithreading:java-多线程
06-09
java-多线程java-多线程用于多线程的 Java 并发 API。
狂神说Java-多线程课程全部代码.rar
11-26
狂神说Java-多线程课程全部代码.rar
Java---Multithreading:Java-多线程
05-18
Java--多线程Java-多线程
java-多线程下载器（支持断点续传、线程加减）包含源码和可运行jar包 第二版
06-17
2、支持多任务多线程同时下载； 3、每个任务的线程数由用户在新建任务时自定义，缺省为5个线程； 4、任务下载过程中可以点击“线程+”或“线程-”即时增减线程； 5、选择任务，可以在任务信息栏中查看任务下载的信息...
java多线程 线程应用实例
许诗宇的博客
11-05 1338
目录 线程的实现 使用内核线程实现 使用用户线程实现 混合实现 Java线程的实现 Java线程调度 状态转换 线程的实现 线程是比进程更轻量级的调度执行单位，线程的引入，可以把一个进程 的资源分配和执行调度分开，各个线程既可以共享进程资源（内存地址、文件I/0等）， 又可以独立调度（线程是CPU调度的最基本单位）。 主流的操作系统都提供了线程实现，Java语言则提供了在不同硬...
Java23多线程4：总结和练习
Bruce的博客
04-04 299
多线程总结和常见问题
Java虚拟线程：一种低成本、轻量级、用户态的Java线程
mxy2404830的博客
12-28 427
OpenJDK在2021-11-15创建了一个草稿版JEP，如下图所示（链接地址：https://openjdk.java.net/jeps/8277131），我们接下来的文章将VIrtual Thread翻译为虚拟线程： 目标 1、为java.lang.Thread增加一种额外的实现，即虚拟线程，它能做到在几个G的JVM堆上创建几百万个活动的虚拟线程（这在现在的JDK中几乎不可能实现），并且表现出和现在的线程几乎一样的行为。2、对虚拟线程问题定位也可以通过已经存在的JDK工具，尽可能保持和现在的线
JDK8升级JDK17过程中遇到的那些坑
Maisuluo的博客
05-24 1519
JDK8虽然非常好，但是JDK版本已经发布到JDK20了，且JDK8后的版本升级了很多新的特性，如模块化、ZGC以虚拟线程、结构性并发等，也是非常有吸引力的，所以决定将基于JDK8的项目升级到最近的LTS版本JDK17。
jmu-java-07多线程-thread
03-16
JMU Java 07 多线程 (Thread) 是指在 Java 语言中使用多个线程来同时执行多个任务的技术。通过使用多线程，可以提高程序的并行处理能力，加快程序的执行速度，提高程序的效率。在 Java 中，多线程可以通过继承 java....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值