首页 > 其他分享 >Thread多线程

Thread多线程

时间:2024-11-05 21:25:13浏览次数:1  
标签:Thread void class 线程 new 多线程 public

多线程

并发与并行(了解)

  • 并行(parallel):指多个事件任务在同一时刻发生(同时发生)。指在同一时刻,有多条指令在多个处理器上同时执行。单核CPU同一时刻只能处理一条指令,所以单核CPU做不到并行处理。
  • 并发(concurrency):指两个或多个事件在同一个微小的时间段内发生。指在同一个时刻只能有一条指令执行,但多个进程的指令被快速轮换执行,使得在宏观上具有多个进程同时执行的效果。程序并发执行可以在有限条件下,充分利用CPU资源,这是我们研究的重点。

并行与并发

单核CPU:只能并发

多核CPU:并行+并发

线程与进程

  • 程序:为了完成某个任务和功能,选择一种编程语言编写的一组指令的集合。

  • 软件:1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。

  • 进程是对一个程序运行过程(创建-运行-消亡)的描述,系统会为每个运行的程序建立一个进程,并为进程分配独立的系统资源,比如内存空间等资源。

  • 线程:线程是进程中的一个执行单元,负责完成执行当前程序的任务,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这时这个应用程序也可以称之为多线程程序。多线程使得程序可以并发执行,充分利用CPU资源。

    面试题:进程是操作系统调度和分配资源的最小单位,线程是CPU调度的最小单位。不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。对于方法区,堆中中的同一个对象的内存,线程之间是可以共享的,但是栈的局部变量永远是独立的。

线程调度

指CPU资源如何分配给不同的线程。常见的两种线程调度方式:

  • 分时调度

    所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。

  • 抢占式调度

    优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java采用的是抢占式调度方式

    • 抢占式调度详解

      大部分操作系统都支持多进程并发运行,现在的操作系统几乎都支持同时运行多个程序。比如:现在我们上课一边使用编辑器,一边使用录屏软件,同时还开着画图板,dos窗口等软件。此时,这些程序是在同时运行,”感觉这些软件好像在同一时刻运行着“。

      实际上,CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。
      其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高。

线程的创建与启动

java虚拟机是支持多线程的,当运行Java程序时,至少已经有一个线程了,那就是main线程。

继承Thread类

Java中java.lang.Thread是表示线程的类,每个Thread类或其子类的实例代表一个线程对象。

通过继承Thread类来创建并启动多线程的步骤:

  1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
  2. 创建Thread子类的实例,即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

自定义线程类:

public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法,指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法,完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+":正在执行!"+i);
		}
	}
}

测试类:创建线程对象并启动线程

public class Demo01 {
	public static void main(String[] args) {
		//创建自定义线程对象
		MyThread mt = new MyThread("新的线程!");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程!"+i);
		}
	}
}

注意事项:

  • 手动调用run方法不是启动线程的方式,只是普通方法调用。

  • start方法启动线程后,run方法会由JVM调用执行。

  • 不要重复启动同一个线程,否则抛出异常IllegalThreadStateException

  • 不要使用Junit单元测试多线程,不支持,主线程结束后会调用System.exit()直接退出JVM;

实现Runnable接口

Java有单继承的限制,当我们无法继承Thread类时,那么该如何做呢?在核心类库中提供了Runnable接口,我们可以实现Runnable接口,重写run()方法,然后再通过Thread类的对象代理启动和执行我们的线程体run()方法

通过实现Runnable接口创建线程并启动的步骤:

  1. 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正
    的线程对象。
  3. 调用线程对象的start()方法来启动线程。

自定义线程任务类:

  public class MyRunnable implements Runnable{
  	@Override  
      public void run() {
          for (int i = 0; i < 20; i++) {
          	System.out.println(Thread.currentThread().getName()+" "+i);         
  		}       
  	}    
  }

测试类:创建线程对象并启动线程

  public class Demo {
      public static void main(String[] args) {
          //创建自定义类对象  线程任务对象
          MyRunnable mr = new MyRunnable();
          //创建线程对象
          Thread t = new Thread(mr, "小强");
          t.start();
          for (int i = 0; i < 20; i++) {
              System.out.println("旺财 " + i);
          }
      }
  }

利用Callable接口、FutureTask对象实现。

可以得到线程执行的结果 通过 FutureTask对象. get()

①、得到任务对象

​ 1.定义类实现Callable接口,重写call方法,封装要做的事情。

import java.util.concurrent.Callable;

public class CallableThread implements Callable {
    @Override
    public Object call() throws Exception {
        int sum =0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

​ 2.用FutureTask把Callable对象封装成线程任务对象。

CallableThread ct = new CallableThread();
FutureTask fk = new FutureTask<>(ct);

②、把线程任务对象交给Thread处理。

③、调用Thread的start方法启动线程,执行任务

Thread thread = new Thread(futureTask);
thread.start();

④、线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

System.out.println(futureTask.get()); 
//callable类
import java.util.concurrent.Callable;
public class CallableThread implements Callable {
    @Override
    public Object call() throws Exception {
        int sum =0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

//test
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableThread callableThread = new CallableThread();
        FutureTask futureTask = new FutureTask<>(callableThread);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

两种创建线程方式比较

  • Thread类本身也是实现了Runnable接口的,run方法都来自Runnable接口,run方法也是真正要执行的线程任务。

    public class Thread implements Runnable {}
    
  • 因为Java类是单继承的,所以继承Thread的方式有单继承的局限性,但是使用上更简单一些。

  • 实现Runnable接口的方式,避免了单继承的局限性,并且可以使多个线程对象共享一个Runnable实现类(线程任务类)对象,从而方便在多线程任务执行时共享数据。

匿名内部类对象创建线程

匿名内部类对象的方式创建线程,并不是一种新的创建线程的方式,只是在线程任务只需执行一次的情况下,我们无需单独创建线程类,可以采用匿名对象的方式:

new Thread("新的线程!"){
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+":正在执行!"+i);
		}
	}
}.start();
new Thread(new Runnable(){
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":" + i);
        }
    }
}).start();

构造方法

  • public Thread() :分配一个新的线程对象。
  • public Thread(String name) :分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字

线程使用基础方法

  • public void run() :此线程要执行的任务在此处定义代码。

  • public String getName() :获取当前线程名称。

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

  • public final int getPriority() :返回线程优先级

  • public final void setPriority(int newPriority) :改变线程的优先级

    • 每个线程都有一定的优先级,优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级,其中setPriority方法需要一个整数,并且范围在[1,10]之间,通常推荐设置Thread类的三个优先级常量:
    • MAX_PRIORITY(10):最高优先级
    • MIN _PRIORITY (1):最低优先级
    • NORM_PRIORITY (5):普通优先级,默认情况下main线程具有普通优先级。
public static void main(String[] args) {
    Thread t = new Thread(){
        public void run(){
            System.out.println(getName() + "的优先级:" + getPriority());
        }
    };
    t.setPriority(Thread.MAX_PRIORITY);
    t.start();

    System.out.println(Thread.currentThread().getName() +"的优先级:" + Thread.currentThread().getPriority());
}

线程控制常见方法

  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

  • public static void sleep(long millis) :线程睡眠,使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。

  • public static void yield() :礼让线程,会将本次抢到的执行权让出去重新再抢

  • void join() :加入线程,当前线程中加入一个新线程,等待加入的线程终止后再继续执行当前线程。

    void join(long millis) :等待该线程终止的时间最长为 millis 毫秒。如果millis时间到,将不再等待。

    void join(long millis, int nanos) :等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

  • public final void stop():强迫线程停止执行。 该方法具有不安全性,已被弃用,最好不要使用

    • 调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作,包括在 catch 或 finally 语句中的,并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获),因此可能会导致一些清理性的工作的得不到完成,如文件,数据库等的关闭。
    • 调用 stop() 方法会立即释放该线程所持有的所有的锁,导致数据得不到同步,出现数据不一致的问题。
  • public void interrupt():中断线程,实际上是给线程打上一个中断的标记,并不会真正使线程停止执行。

  • public static boolean interrupted():检查线程的中断状态,调用此方法会清除中断状态(标记)。

  • public boolean isInterrupted():检查线程中断状态,不会清除中断状态(标记)

倒计时(sleep)

	public static void main(String[] args) {
		for (int i = 10; i>=0; i--) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("新年快乐!");
	}

强行加塞(join)

加入线程,当前线程中加入一个新线程,等待加入的线程终止后再继续执行当前线程。

import java.util.Scanner;

public class TestJoin {
	public static void main(String[] args) {
		ChatThread t = new ChatThread();
		t.start();
		for (int i = 1; i <= 10; i++) {
			System.out.println("main:" + i);
         //当main打印到5之后,需要等join进来的线程停止后才会继续了。
			if(i==5){
				try {
					t.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}
class ChatThread extends Thread{
	public void run(){
		Scanner input = new Scanner(System.in);
		while(true){
			System.out.println("是否结束?(Y、N)");
			char confirm = input.next().charAt(0);
			if(confirm == 'Y' || confirm == 'y'){
				break;
			}
		}
		input.close();
	}
}

守护线程(线程名.setDaemon(true))

当其他非守护线程执行完毕之后,守护线程会陆续结束。

public class TestThread {
	public static void main(String[] args) {
		MyDaemon m = new MyDaemon();
		m.setDaemon(true);
		m.start();

		for (int i = 1; i <= 100; i++) {
			System.out.println("main:" + i);
		}
	}
}

class MyDaemon extends Thread {
	public void run() {
		while (true) {
			System.out.println("我一直守护者你...");
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

线程安全

当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候,但是如果多个线程中对资源有读和写的操作,就会出现前后数据不一致问题,这就是线程安全问题。

线程安全问题引出

局部变量不能共享

示例代码:

package com.atguigu.safe;

public class SaleTicketDemo1 {
	public static void main(String[] args) {
		Window w1 = new Window();
		Window w2 = new Window();
		Window w3 = new Window();
		
		w1.start();
		w2.start();
		w3.start();
	}
}
class Window extends Thread{
	public void run(){
		int total = 100;
		while(total>0) {
			System.out.println(getName() + "卖出一张票,剩余:" + --total);
		}
	}
}

结果:发现卖出300张票。

问题:局部变量是每次调用方法都是独立的,那么每个线程的run()的total是独立的,不是共享数据。

不同对象的实例变量不共享

package com.atguigu.safe;

public class SaleTicketDemo2 {
	public static void main(String[] args) {
		TicketSaleThread t1 = new TicketSaleThread();
		TicketSaleThread t2 = new TicketSaleThread();
		TicketSaleThread t3 = new TicketSaleThread();
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class TicketSaleThread extends Thread{
	private int total = 10;
	public void run(){
		while(total>0) {
			System.out.println(getName() + "卖出一张票,剩余:" + --total);
		}
	}
}

结果:发现卖出300张票。

问题:不同的实例对象的实例变量是独立的。

静态变量是共享的

示例代码:

package com.atguigu.safe;

public class SaleTicketDemo3 {
	public static void main(String[] args) {
		TicketThread t1 = new TicketThread();
		TicketThread t2 = new TicketThread();
		TicketThread t3 = new TicketThread();
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class TicketThread extends Thread{
	private static int total = 10;
	public void run(){
		while(total>0) {
			try {
				Thread.sleep(10);//加入这个,使得问题暴露的更明显
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(getName() + "卖出一张票,剩余:" + --total);
		}
	}
}

结果:发现卖出近100张票。

问题(1):但是有重复票或负数票问题。

原因:线程安全问题

问题(2):如果要考虑有两场电影,各卖100张票,这场卖完就没票了,新的线程对象也没有票卖了

原因:TicketThread类的静态变量,是所有TicketThread类的对象共享。本来成员变量就是run方法共享的数据,再用static不合适。

同一个对象的实例变量共享

示例代码:多个Thread线程使用同一个Runnable对象

package com.atguigu.safe;

public class SaleTicketDemo3 {
	public static void main(String[] args) {
		TicketSaleRunnable tr = new TicketSaleRunnable();
		Thread t1 = new Thread(tr,"窗口一");
		Thread t2 = new Thread(tr,"窗口一");
		Thread t3 = new Thread(tr,"窗口一");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class TicketSaleRunnable implements Runnable{
	private int total = 10;
	public void run(){
		while(total>0) {
			try {
				Thread.sleep(10);//加入这个,使得问题暴露的更明显
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖出一张票,剩余:" + --total);
		}
	}
}

结果:发现卖出近100张票。

问题:但是有重复票或负数票问题。

原因:线程安全问题

线程安全问题原因分析

总结:线程安全问题的出现因为具备了以下条件

  1. 多线程执行
  2. 共享数据
  3. 多条语句操作共享数据

线程安全问题解决方式

lock锁:

  • 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便。
  • Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。
  • Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象。
方法名称 说明
public ReentrantLock() 获得Lock锁的实现类对象
方法名称 说明
void lock() 获得锁
void unlock() 释放锁
static Lock lock = new ReentrantLock(); 
lock.lock()  //加锁
  try{
     //被锁的代码 
  }catch(Execption e){
      //处理异常
  }finally{
      lock.unlock(); //释放锁
  }

Java中常使用关键字synchronized 来实现同步机制:

同步方法:synchronized 关键字直接修饰方法,表示同一时刻只有一个线程能进入这个方法,其他线程在外面等着。

public synchronized void method(){
    // 普通同步方法的锁对象是 this:
}
public static synchronized void method(){
    //静态同步方法的锁对象是: 类名.class
}

普通方法的锁

public class Account {
    int balance =1000;
    public void withDraw(int money){
        balance-=money;
    }
    //普通方法的锁
    public synchronized void takeMoney() {
        if (balance >= 800) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
           withDraw(800);
            System.out.println(Thread.currentThread().getName() + " 取钱成功,余额是[" + balance + "]元");
        } else {
            System.out.println(Thread.currentThread().getName() + " 取钱失败 余额不足,余额是[" + balance + "]元");
        }
    }
}
//线程1
public class DiaoChanThread extends Thread{
    Account account;
    public DiaoChanThread(Account account) {
        this.account = account;
    }
    @Override
    public void run() {
        account. takeMoney();
    }
}
//线程2
public class LvBuThread extends Thread{
    Account account;
    public LvBuThread(Account account) {
        this.account = account;
    }
    @Override
    public void run() {

        account.takeMoney();
    }
}

//test
public class Test {
    public static void main(String[] args) {
        Account account = new Account();
        LvBuThread lb = new LvBuThread(account);
        DiaoChanThread dc = new DiaoChanThread(account);

        lb.setName("吕布");
        dc.setName("貂蝉");

        lb.start();
        dc.start();
    }
}

静态方法的锁

public class Account {
   static int balance =1000;
    public static void withDraw(int money){
        balance-=money;
    }

    //Account.class
    public static synchronized void takeMoney(){

        //1.校验余额
        if(balance>=800){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //2.取钱
            withDraw(800);

            System.out.println(Thread.currentThread().getName()+" 取钱成功,余额是["+balance+"]元");
        }else{
            //3.余额不足提示
            System.out.println(Thread.currentThread().getName()+" 取钱失败 余额不足,余额是["+balance+"]元");
        }

    }
}
//线程1
public class DiaoChanThread extends Thread{
    @Override
    public void run() {
        Account.takeMoney();

    }
}
//
public class LvBuThread extends Thread{
    @Override
    public void run() {
        Account.takeMoney();

    }
}
//test
public class Test {
    public static void main(String[] args) {
        LvBuThread lb = new LvBuThread();
        DiaoChanThread dc = new DiaoChanThread();

        lb.setName("吕布");
        dc.setName("貂蝉");

        lb.start();
        dc.start();
    }
}

同步代码块:synchronized 关键字可以用于某个区块前面,表示只对这个区块的资源实行互斥访问。
格式:

synchronized(锁对象/同步监视器对象){
     需要同步操作的代码
}
//注意:
//1.只有锁对象相同才会有互斥效果 一个线程进入同步代码块 其他线程无法进入
//售票线程任务类
class SaleTicket implements Runnable {
    private int count = 100;

    //售票线程任务
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                sell();//调用售票方法
            }

        }
    }
    //提取出售票方法
    private  void sell() {
        if (count > 0) {
            System.out.println(Thread.currentThread().getName() + "--" + count);
            count--;
        }
    }
}


//测试类
public class DemoSaleTicket {
    public static void main(String[] args) {
        //创建线程任务对象  使用实现Runnable接口可以直接使用非静态方法同步 因为只会创建一个对象
        SaleTicket st = new SaleTicket(ticket);
        
        //创建售票线程对象,并启动线程
        new Thread(st).start();
        new Thread(st).start();

    }
}
  • 锁的范围太小:不能解决安全问题,要同步所有操作共享资源的语句。
  • 锁的范围太大:因为一旦某个线程抢到锁,其他线程就只能等待,所以范围太大,效率会降低,不能合理利用CPU资源。

单例设计模式的线程安全问题

设计模式:设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
       是软件工程中解决特定问题的最佳实践方案。它们提供了一种在软件开发中遇到常见问题时,可复用的、经过验证的解决方案

饿汉式没有线程安全问题

饿汉式:上来就创建对象

package com.atguigu.thread4;

public class OnlyOneDemo {
	public static void main(String[] args) {
		OnlyOne o1 = OnlyOne.INSTANCE;
		OnlyOne o2 = OnlyOne.INSTANCE;
		
		System.out.println(o1);
		System.out.println(o2);
		System.out.println(o1==o2);
	}
}
class OnlyOne{
	public static final OnlyOne INSTANCE = new OnlyOne();
	//私有化构造器
    private OnlyOne(){
		
	}
}

懒汉式线程安全问题

public class Singleton {
    private static Singleton ourInstance;

    public static Singleton getInstance() {
        //一旦创建了对象,之后再次获取对象,都不会再进入同步代码块,提升效率
        if (ourInstance == null) {
            
            //同步锁,锁住判断语句与创建对象并赋值的语句
            synchronized (Singleton.class) {
                if (ourInstance == null) {
                    ourInstance = new Singleton();
                }
            }
        }
        return ourInstance;
    }
    //私有化构造器
    private Singleton() {
    }
}

线程间通信

为什么要处理线程间通信:

多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。而多个线程并发执行时, 在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行, 那么多线程之间需要一些通信机制,可以协调它们的工作,以此来帮我们达到多线程共同操作一份数据。

比如:线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,此时B线程必须等到A线程完成后才能执行,那么线程A与线程B之间就需要线程通信

等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。

就是在一个线程满足某个条件时,就进入等待状态(wait()/wait(time)), 等待其他线程执行完他们的指定代码过后再将其唤醒(notify());或可以指定wait的时间,等时间到了自动唤醒;在有多个线程进行等待时,如果需要,可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

  1. wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING或TIMED_WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”或者等待时间到,在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中
  2. notify:则选取所通知对象的 wait set 中的一个线程释放;
  3. notifyAll:则释放所通知对象的 wait set 上的全部线程。

注意:

被通知线程被唤醒后也不一定能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下:

  • 如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE(可运行) 状态;
  • 否则,线程就从 WAITING 状态又变成 BLOCKED(等待锁) 状态
调用wait和notify方法需要注意的细节
  1. wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
  3. wait方法与notify和notifyAll方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这3个方法

线程通信四步骤:

//循环
//同步代码块
//判断,共享数据是否到了末尾(已经到末尾)
//判断,共享数据是否到了末尾(没有到末尾)
public class Ticket extends Thread {
    public static int count = 100;

    public Ticket(String name) {
        super(name);
    }

    @Override
    public void run() {
        //循环
        while (count > 0) {
            //同步代码块 封装了
            sell();
        }
    }
    
    public static synchronized void sell() {
        //判断,共享数据是否到了末尾(已经到末尾)
        //判断,共享数据是否到了末尾(没有到末尾)
        if(count>0) System.out.println(Thread.currentThread().getName() + "卖了一张票,还剩" + --count + "张");
    }
}

public class Test {
    public static void main(String[] args) {
        /**两个线程卖1000张票*/
        Ticket ticket1 = new Ticket("窗口1");
        Ticket ticket2 = new Ticket("窗口2");
        ticket1.start();
        ticket2.start();
    }
}

生产者与消费者问题

等待唤醒机制可以解决经典的“生产者与消费者”的问题。

生产者与消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个(多个)共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。

生产者与消费者问题中其实隐含了两个问题:

  • 线程安全问题:因为生产者与消费者共享数据缓冲区,不过这个问题可以使用同步解决。
  • 线程的协调工作问题:
    • 要解决该问题,就必须让生产者线程在缓冲区满时等待(wait),暂停进入阻塞状态,等到下次消费者消耗了缓冲区中的数据的时候,通知(notify)正在等待的线程恢复到就绪状态,重新开始往缓冲区添加数据。同样,也可以让消费者线程在缓冲区空时进入等待(wait),暂停进入阻塞状态,等到生产者往缓冲区添加数据之后,再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。

一个厨师一个服务员问题

案例:有家餐馆的取餐口比较小,只能放10份快餐,厨师做完快餐放在取餐口的工作台上,服务员从这个工作台取出快餐给顾客。现在有1个厨师和1个服务员。

public class TestCommunicate {
	public static void main(String[] args) {
		// 1、创建资源类对象
		Workbench workbench = new Workbench();

		// 2、创建和启动厨师线程
		new Thread("厨师") {
			public void run() {
				while (true) {
					workbench.put();
				}
			}
		}.start();

		// 3、创建和启动服务员线程
		new Thread("服务员") {
			public void run() {

				while (true) {
					workbench.take();
				}
			}
		}.start();
	}

}

// 1、定义资源类
class Workbench {
	private static final int MAX_VALUE = 10;
	private int num;
    //做餐
	public synchronized void put() {
		if (num >= MAX_VALUE) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		num++;
		System.out.println(Thread.currentThread().getName() + "制作了一份快餐,现在工作台上有:" + num + "份快餐");
		this.notify();
	}
    //取餐
	public synchronized void take() {
		if (num <= 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		num--;
		System.out.println(Thread.currentThread().getName() + "取走了一份快餐,现在工作台上有:" + num + "份快餐");
		this.notify();
	}
}

多个厨师多个服务员问题

案例:有家餐馆的取餐口比较小,只能放10份快餐,厨师做完快餐放在取餐口的工作台上,服务员从这个工作台取出快餐给顾客。现在有多个厨师和多个服务员。

public class TestCommunicate2 {
	public static void main(String[] args) {
		// 1、创建资源类对象
		WindowBoard windowBoard = new WindowBoard();

		// 2、创建和启动厨师线程
		// 3、创建和启动服务员线程
		Cook c1 = new Cook("张三",windowBoard);
		Cook c2 = new Cook("李四",windowBoard);
		Waiter w1 = new Waiter("小红",windowBoard);
		Waiter w2 = new Waiter("小绿",windowBoard);
		
		c1.start();
		c2.start();
		w1.start();
		w2.start();
	}

}
//1、定义资源类
class WindowBoard {
	private static final int MAX_VALUE = 10;
	private int num;
    
    //做餐
	public synchronized void put() {
		while (num >= MAX_VALUE) {//必须循环判断。
			try {
				this.wait();//wait后会释放锁,Cooker1线程释放后,Cooker2线程获得锁(本应Waiter获得)进来后if继续wait,释放锁,Cooker1又快速获得锁,继续向下执行。。。
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		num++;
		System.out.println(Thread.currentThread().getName() + "制作了一份快餐,现在工作台上有:" + num + "份快餐");
		this.notifyAll();
	}
    //取餐
	public synchronized void take() {
		while (num <= 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		num--;
		System.out.println(Thread.currentThread().getName() + "取走了一份快餐,现在工作台上有:" + num + "份快餐");
		this.notifyAll();
	}
}


//2、定义厨师类
class Cook extends Thread{
	private WindowBoard windowBoard;
	
	public Cook(String name,WindowBoard windowBoard) {
		super(name);
		this.windowBoard = windowBoard;
	}

	public void run(){
		while(true) {
			windowBoard.put();
		}
	}
}


//3、定义服务员类
class Waiter extends Thread{
	private WindowBoard windowBoard;
	
	public Waiter(String name,WindowBoard windowBoard) {
		super(name);
		this.windowBoard = windowBoard;
	}

	public void run(){
		while(true) {
			windowBoard.take();
		}
	}
}

练习

一个数字线程打印数字:  1 2 3 4 5.....52
一个字母线程打印字母:  A B C D E F.... Z
两个线程进行协作
最终效果:
1 2 A 3 4 B 5 6 C 7  8  D  9  10  E.... 51 52 Z
-----------------------------------
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15....
思路:
	每一个值占用一个位置如果是3的倍数打印字母否则打印数字
//静态同步方法实现
public class Test {

    public static void main(String[] args) {

        NumThread numThread = new NumThread();
        CharThread charThread = new CharThread();
        numThread.start();
        charThread.start();

    }
}

public class Print {
    //记录位置
    static int position = 1;
    //打印数字的方法
    public static synchronized void printNum(int num) throws InterruptedException {
        //如果是3的倍数  数字线程等待
        while (position % 3 == 0) {
            Print.class.wait();
        }
        Thread.sleep(20);
        //展示数字
        System.out.print(num + " ");

        //更改位置
        position++;
        //通知字母线程打印字母
        Print.class.notifyAll();
    }

    //打印字母的方法
    public static synchronized void printChar(char c) throws InterruptedException {
        //如果不是3的倍数  字母线程等待
        while (position % 3 != 0) {
            Print.class.wait();
        }
        //打印字母
        System.out.print(c + " ");

        //更改位置
        position++;
        //通知数字线程执行
        Print.class.notifyAll();

    }

}

public class NumThread  extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <=52 ; i++) {

            try {
                Print.printNum(i);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
class CharThread extends Thread{
    @Override
    public void run() {
        for(char c='A';c<='Z';c++){
            try {
                Print.printChar(c);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

线程生命周期

传统线程模型的五种线程状态(简单)

传统线程模型中把线程的生命周期描述为五种状态:新建(New)就绪(Runnable)运行(Running)阻塞(Blocked)死亡(Dead)。CPU需要在多条线程之间切换,于是线程状态会多次在运行、阻塞、就绪之间切换。

1. 新建

当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状。此时它和其他Java对象一样,仅仅由JVM为其分配了内存,并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征,程序也不会执行它的线程体run()。

2. 就绪

但是当线程对象调用了start()方法之后,线程就从新建状态转为就绪状态。这时线程并未执行,只是具备了运行的条件,还需要获取CPU资源后才能执行。

3. 运行

如果处于就绪状态的线程获得了CPU资源,开始执行run()方法的线程体代码,则该线程处于运行状态。如果计算机只有一个CPU,在任何时刻只有一个线程处于运行状态,如果计算机有多个处理器,将会有多个线程并行(Parallel)执行。

当然,美好的时光总是短暂的,而且CPU讲究雨露均沾。对于抢占式策略的系统而言,系统会给每个可执行的线程一个小时间段来处理任务,当该时间用完,系统会剥夺该线程所占用的资源,让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会,而在选择下一个线程时,系统会适当考虑线程的优先级。

4. 阻塞

当在运行过程中的线程遇到某些特殊情况时,线程会临时放弃CPU资源,不再执行,即进入阻塞状态。比如:线程调用了sleep()方法,会主动放弃所占用的CPU资源。

5. 死亡

线程完成任务结束或意外终止后,线程就处于死亡状态。

JDK定义的六种线程状态(了解)

java.lang.Thread类内部定义了一个枚举类用来描述线程的六种状态:

    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

跟传统线程模型中的线程状态不同的是:

  1. 枚举类中没有区分就绪运行状态,而是定义成了一种状态Runnable

    • 因为对于Java对象来说,只能标记为可运行,至于什么时候运行,不是JVM来控制的了,是OS来进行调度的,而且时间非常短暂,因此对于Java对象的状态来说,无法区分。只能我们人为的进行想象和理解。
  2. 传统模型中的阻塞状态在枚举类的定义中又细分为了三种状态的:BLOCKEDWAITINGTIMED_WAITING

    • BLOCKED:是指互有竞争关系的几个线程,其中一个线程占有锁对象时,其他线程只能等待锁。只有获得锁对象的线程才能有执行机会。

    • TIMED_WAITING:当前线程执行过程中遇到Thread类的sleep或join,Object类的wait,LockSupport类的park方法,并且在调用这些方法时,设置了时间,那么当前线程会进入TIMED_WAITING,直到时间到,或被中断。

    • WAITING:当前线程执行过程中遇到遇到Object类的wait,Thread类的join,LockSupport类的park方法,并且在调用这些方法时,没有指定时间,那么当前线程会进入WAITING状态,直到被唤醒。

      • 通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒;

      • 通过Condition的await进入WAITING状态的要有Conditon的signal方法唤醒;

      • 通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒

      • 通过Thread类的join进入WAITING状态,只有调用join方法的线程对象结束才能让当前线程恢复;

    说明:当从WAITINGTIMED_WAITING恢复到Runnable状态时,如果发现当前线程没有得到监视器锁,那么会立刻转入BLOCKED状态。

image-20200521184149034

释放锁的操作

  • 当前线程的同步方法、同步代码块执行结束。

  • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致当前线程异常结束。

  • 当前线程在同步代码块、同步方法中执行了锁对象的wait()方法,当前线程被挂起,并释放锁。

死锁

不同的线程分别锁住对方需要的同步监视器对象不释放,都在等待对方先放弃时就形成了线程的死锁。一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。

public class TestDeadLock {
	public static void main(String[] args) {
		Object g = new Object();
		Object m = new Object();
		Owner s = new Owner(g,m);
		Customer c = new Customer(g,m);
		new Thread(s).start();
		new Thread(c).start();
	}
}
class Owner implements Runnable{
	private Object goods;
	private Object money;

	public Owner(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (goods) {
			System.out.println("先给钱");
			synchronized (money) {
				System.out.println("发货");
			}
		}
	}
}
class Customer implements Runnable{
	private Object goods;
	private Object money;

	public Customer(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (money) {
			System.out.println("先发货");
			synchronized (goods) {
				System.out.println("再给钱");
			}
		}
	}
}

面试题:sleep()和wait()方法的区别

(1)sleep()不释放锁,wait()释放锁

(2)sleep()指定休眠的时间,wait()可以指定时间----也可以无限等待直到notify或notifyAll

(3)sleep()在Thread类中声明的静态方法,wait方法在Object类中声明

​ 调用wait()方法是由锁对象调用,而锁对象的类型是任意类型的对象。

wait需要写到synchronized(锁对象中)不然会报运行时错误。

标签:Thread,void,class,线程,new,多线程,public
From: https://www.cnblogs.com/21CHS/p/18528870

相关文章

  • Qt多线程- QThread 创建多线程程序
    QThread创建多线程程序QThread类功能简介今天说一下Qt中的多线程。QThread类不依赖平台的管理线程的方法。一个QThread类的对象管理一个线程,一般从QThread继承一个自定义类,并重新定义虚函数run(),在run()函数里实现线程需要完成的任务。将应用程序的线程称为......
  • Java多线程编程(三)一>详解synchronized, 死锁,wait和notify
    目录: 一.synchronized的使用:   二. 常见死锁情况: 三.如何避免死锁:  四.wait和notify一.synchronized的使用: 我们知道synchronized锁具有互斥的特点:synchronized会起到互斥效果,某个线程执行到某个对象的synchronized中时,其他线程如果也执......
  • Python中的生产者-消费者模型:多进程与多线程的实践
    Python中的生产者-消费者模型:多进程与多线程的实践在现代编程中,生产者-消费者模型是一种常见的设计模式,用于处理任务队列和并发执行。Python提供了多种工具来实现这一模型,包括threading模块和multiprocessing模块。本文将通过一个实际的案例——从网页上批量下载图片——来......
  • 【Python】全面解析Python中的GIL(全局解释器锁):多线程与多进程的实战与抉择
    解锁Python编程的无限可能:《奇妙的Python》带你漫游代码世界Python中的GIL(全局解释器锁)对多线程并发执行的限制性影响是开发者在性能优化时需要特别关注的内容。本文将详细讨论GIL的工作机制及其对多线程性能的影响,深入分析Python多线程在CPU密集型和I/O密集型任......
  • RT-Thread、RT-Linux与Zephyr实时性对比
    在嵌入式系统领域,实时性是一个至关重要的指标,它直接关系到系统对外部事件的响应速度和处理效率。在众多实时操作系统(RTOS)中,RT-Thread、RT-Linux和Zephyr因其各自的特点和优势,成为业界广泛关注的焦点。本文将从实时性角度出发,对这三款RTOS进行详细对比。 一、引言随着物联网、......
  • Java 多线程售票示例
     1、售票任务类:packagecom.joyupx.cms.example.globalLock5;importcn.hutool.core.date.DateTime;importlombok.extern.slf4j.Slf4j;importstaticjava.lang.Thread.sleep;/***售票任务*@authorhapday*@since0.0.1*/@Slf4jpublicclassSellTicketT......
  • 初始JavaEE篇——多线程(7):定时器、CAS
    找往期文章包括但不限于本期文章中不懂的知识点:个人主页:我要学编程程(ಥ_ಥ)-CSDN博客所属专栏:JavaEE目录定时器的使用定时器的原理 模拟实现定时器 CAS介绍CAS的应用场景 解析AtomicInteger类实现自旋锁CAS的缺陷:ABA问题 现在我们来学习最后一个多线程......
  • C++多线程:atomic
    在许多为了性能和效率的场景下,需要开发一些lock-free的算法和数据结构atomic_flag原子布尔类型,只支持test-and-set和clear操作构造函数atomic_flag()noexcept=default;atomic_flag(constatomic_flag&)=delete;只有默认构造函数,而不能从其他对象构造atomic_flag对象需......
  • C++多线程:thread
    进程与线程进程:系统资源分配的最小单元,通常被定义为一个正在运行的程序实例线程:系统任务调度的最小单元进程间通信:管道,信号量,信号,消息队列,共享内存,套接字线程间通信:锁机制,信号量机制,信号机制,屏障同步:保证任务片段的先后顺序互斥:为了保证资源在同一时刻只能被一个线程使用,即......
  • C++多线程:mutex
    互斥量C++11互斥锁定义在<mutex>头文件中,提供了独占资源的特性C++11头文件中定义的互斥量互斥量说明mutex基本互斥量recursive_mutex递归互斥量timed_mutex定时互斥量recursive_timed_mutex递归定时互斥量std::mutex最基本的互斥量,提供了独占所有权......