Day13.14_多线程 ( 一 )

最新推荐文章于 2024-08-24 17:09:16 发布
最新推荐文章于 2024-08-24 17:09:16 发布
阅读量325 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41612797/article/details/108093002
版权

文章目录

基础多线程

一. 基本概念

串行，并行，并发

  • 串行：指多个事件一个接一个依次执行(依次发生)。Serial
  • 并行：指多个事件在同一时刻发生(同时发生)。Parallel
  • 并发：指多个事件在同一个时间段内发生 (分时串行)。Concurrent

并发指的是在一段时间内宏观上有多个程序同时运行。

在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行。

在多 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。

线程同理，从宏观角度上线程是并行运行的，但是从微观角度上却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，这种情况称为线程调度。

什么是进程 ？

进程，是指一个内存中运行的应用程序。程序是静止的，只有真正运行时的程序，才被称为进程。

单核CPU在任何时间点上，只能运行一个进程，宏观并行、微观串行，

什么是线程 ？

线程，又称轻量级进程(Light)，是程序中的一个顺序控制流程。

进程由多个线程组成，彼此间完成不同的工作，交替执行，称为多线程。

进程与线程的区别

  • 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位
  • 一个程序运行后至少有一个进程。
  • 一个进程可以包含多个线程，但是至少需要一个线程。
  • 进程间不能共享数据段地址，但同进程的线程之间可以。

线程调度

  • 分时调度

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

  • 抢占式调度

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

二. 线程的组成

组成*

任何一个人线程都具有基本的组成部分：

  • CPU时间片：操作系统(OS)会为每个线程分配执行时间。
  • 运行数据：
    • 堆空间：存储线程需使用的对象，多个线程可以共享堆中的对象。
    • 栈空间：存储线程需使用的局部变量，每个线程都拥有独立的栈。
  • 线程的逻辑代码

创建线程类*

方式一：继承Thread类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用就是执行一段程序流。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类
  2. 覆盖该类的 run() 方法。run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
  3. 创建Thread子类的实例，即创建了线程对象
  4. 调用线程对象的 start() 方法来启动该线程
public class TestCreateThread {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();	// 3.创建子类对象
        t1.start();	// 4.调用start()方法
        for (int i = 1; i <= 50; i++) {
            System.out.println("main主线程:" + i);
        }
    }
}
class MyThread extends Thread {	// 1.继承Thread类
    @Override
    public void run() { // 2.覆盖run()方法
        for (int i = 1; i <= 50; i++) {
            System.out.println("自定义线程:" + i);
        }
    }
}

程序启动运行main时候，JVM启动一个进程，主线程main在main()调用时候被创建。

随着调用t1对象的start方法，另外一个新的线程也启动了，此时整个应用就在多线程下运行。 CPU在多个线程之间来回切换,随机选择一条执行。

多线程执行时，在栈内存中，每一个执行线程都有一片自己所属的栈内存空间，进行方法的压栈和弹栈，互不影响。

当执行线程的任务结束了，线程自动在栈内存中释放了。

当所有的执行线程都结束了，进程就结束了。

Thread类常用方法
// === 构造方法 ===
public Thread()	// 分配一个新的线程对象。 
public Thread(String name)	// 分配一个指定名字的新的线程对象。 
public Thread(Runnable target)	// 分配一个带有指定目标新的线程对象。 
public Thread(Runnable target,String name)	// 分配一个带有指定目标新的线程对象并指定名字。  

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

public void start()	// 此线程开始执行; JVM调用此线程的run方法。 

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

public static void sleep(long millis)	// 当前线程主动休眠millis毫秒

public static void yield() // 当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片

public final void join() // 等待该线程终止，终止后其它线程才可执行

public final void setDaemon(boolean on)	// 将此线程标记为守护线程或用户线程。当运行的所有线程为守护线程时，JVM退出。

public static Thread currentThread()	// 返回对当前正在执行的线程对象的引用。
方式二：实现Runnable接口

采用 java.lang.Runnable 创建线程也非常常见，只需要重写run方法即可。

public interface Runnable {
    void run();
}

步骤如下：

  1. 定义Runnable接口的实现类，
  2. 覆盖该接口的 run() 方法，该run()方法的方法体同样是该线程的线程执行体。
  3. 创建Runnable实现类的实例
  4. 以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  5. 调用线程对象的 start() 方法来启动线程。
public class TestCreateThread {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();	// 3.创建实现类对象
        Thread t2 = new Thread(mr);	// 4.创建线程对象
        t2.start();	// 5.调用start()方法
    }
}
class MyRunnable implements Runnable {	// 1.实现Runnable接口
    @Override
    public void run() { // 2.覆盖run()方法
        for (int i = 1; i <= 50; i++) {
            System.out.println("MyThread:" + i);
        }
    }
}

通过实现Runnable接口，使得该类有了多线程类的特征。

run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的。

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。

而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

也可使用匿名内部类

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，覆盖Runnable接口中的run方法。

public class NoNameInnerClassThread { 
	public static void main(String[] args) { 
        //‐‐‐这个整体 相当于new MyRunnable() 
        Runnable r = new Runnable(){ 
            public void run(){ 
                for (int i = 0; i < 20; i++) { 
                    System.out.println("MyThread:" + i); 
                } 
            } 
        };
        
        new Thread(r).start();
	}
}

Thread 和 Runnable 的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

实现Runnable接口 比 继承Thread类所具有的优势：

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免java中的单继承的局限性。
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
  4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

【扩】：

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

方式三：实现Callable接口 + FutureTask包装器
public interface Callable<V> {
    V call() throws Exception;
}

详见 Day15_多线程 ( 二 ) 五.线程池 — Callable接口 — 【例】

Runnable 和 Callable的区别

  1. Runnable执行方法是run()，Callable是call()
  2. 实现Runnable接口的任务线程无返回值；实现Callable接口的任务线程能返回执行结果
  3. call方法可以抛出异常，run方法若有异常只能在内部消化
  4. Runnable可以作为Thread构造器的参数，通过开启新的线程来执行，也可以通过线程池来执行。而Callable只能通过线程池执行。
方式四：使用ExecutorService、Callable、Future实现

详见 Day15_多线程 ( 二 ) 五.线程池 — Future接口 — 【例】

【例】：多窗口独立售票

要求：封装一个卖票的线程 ，每个线程都有100张票 。实现3个线程同时卖票 ，卖完为止。

自定义线程类：

public class MyThread extends Thread {
	@Override
	public void run() {
		int count = 1;
		while (true) {
			if (count == 101) {
				System.out.println(this.getName() + " 票卖完了");
				break;
			}
			System.out.println(this.getName() + " 卖出第 " + count + " 张票");
			count++;
		}
	}
}

测试类

public class TestThread {
	public static void main(String[] args) {
		ticketing("窗口1");
		ticketing("窗口2");
		ticketing("窗口3");
        //static Thread currentThread() 返回对当前正在执行的线程对象的引用      
        System.out.println(Thread.currentThread().getName());
	}
	public static void ticketing(String name) {
		MyThread myThread = new MyThread();
		myThread.setName(name);
		myThread.start();
	}
}

线程优先级

Java使用的为抢占式调度。

优先级相关方法
final int getPriority()	// 返回此线程的优先级
final void setPriority(int newPriority)	// 更改此线程的优先级

【注】：线程默认优先级是5；线程优先级的范围是：1-10

【注】：优先级只是修改了抢占到时间片的概率，并不保证高优先级的程序一定优先执行。

【例】：多窗口按优先级独立售票

仍然使用上面的自定义线程类 ：MyThread 。

public class TestThreadPriority {
	public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();
        myThread1.setName("窗口1");
        myThread2.setName("窗口2");
        myThread3.setName("窗口3");
        
        //public final int getPriority()：返回此线程的优先级
        System.out.println(tp1.getPriority()); //5
        System.out.println(tp2.getPriority()); //5
        System.out.println(tp3.getPriority()); //5
        //System.out.println(Thread.MAX_PRIORITY); //10
        //System.out.println(Thread.MIN_PRIORITY); //1
        //System.out.println(Thread.NORM_PRIORITY); //5
        
        //public final void setPriority(int newPriority)：更改此线程的优先级
        //myThread1.setPriority(10000); //IllegalArgumentException

        //设置正确的优先级
        myThread1.setPriority(1);
        myThread2.setPriority(5);
        myThread3.setPriority(10);

        myThread1.start();
        myThread2.start();
        myThread3.start();
	}	
}

三. 线程安全

什么是线程安全问题 ？

还是售票的例子，

如果只有一个窗口，那么相当于单线程程序，是不会引发线程安全问题。

如果是多个窗口各自卖自己手中的100张票，即多线程程序，但没有访问共享数据，也不会产生问题。

可实际生活中，多个窗口可能因售票员操作带来的出票速度不同，或顾客排队不均匀，导致每个窗口实际出票的数量不同。为了协调分配票的数量，避免【有的窗口有余票，而其他窗口缺票】的情况出现，会将所有的票放在一起来卖，各个窗口售票时再从中取出。

即多个线程共享数据段。此时可能会出现重复出票的情况，即线程不安全。

线程不安全：

  • 当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致。
  • 临界资源：共享资源(同一对象)，一次仅允许一个线程使用，才可保证其正确性。
  • 原子操作：不可分割的多步操作，被视作一个整体，其顺序和步骤不可打乱或缺省。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

如何处理线程不安全 ？

对于低频次的少量读写操作，可以用sleep()进行延时解决。

而对于更大的数据量和更复杂的处理过程，延时将大大影响性能。

此时需要引入线程同步机制。

如何完成同步操作 ？

1. 同步代码块：
synchronized(临界资源对象/同步锁) {	// 对临界资源对象加锁
    // 需要同步操作的代码(原子操作)
}

【注】：

  • 每个对象都有一个互斥锁标记，用来分配给线程的。多个线程对象 要使用同一把锁。
  • 在任何时候,最多允许一个线程拥有互斥锁标记。
  • 只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块，其他的线程只能在外等着。
  • 线程退出同步代码块时，会释放相应的互斥锁标记。

互斥是通过竞争对资源的独占使用，彼此之间不需要知道对方的存在，执行顺序是一个乱序。
同步是协调多个相互关联线程合作完成任务，彼此之间知道对方存在，执行顺序往往是有序的。

2. 同步方法：
修饰符 synchronized 返回值类型 方法名称(形参列表) {	// 对当前对象(this)加锁
    // 代码(原子操作)
}

【注】：

  • 只有拥有对象互斥锁标记的线程，才能进入该对象加锁的同步方法中。
  • 线程退出同步方法时，会释放相应的互斥锁标记。
synchronized作用于静态方法和非静态方法的区别:

非静态方法：给对象加锁 【this】( 可以理解为给这个对象的内存上锁。注意，只是这块内存,其他同类对象都会有各自的内存锁 ) ，这时候在其他线程中执行该对象的这个同步方法 ( 注意：是该对象 ) 就会产生互斥

静态方法：相当于在类上加锁【类名.class】 ( 类名.class 位于代码区，静态方法位于静态区域，这个类产生的对象公用这个静态方法，所以这块内存，N个对象来竞争)，这时候,只要是这个类产生的对象，在调用这个静态方法时都会产生互斥

同步规则

【注】：

  • 只有在调用包含同步代码块的方法，或者同步方法时，才需要对象的锁标记。
  • 如调用不包含同步代码块的方法，或普通方法时，则不需要锁标记，可直接调用。
已知JDK中线程安全的类：
  • StringBuffer：可变的字符序列
  • Vector
  • Hashtable
  • 以上类中的公开方法，均为synchonized修饰的同步方法。
3. 锁机制：

详见 Day15_多线程 ( 二 ) 五.线程池 — Lock接口

线程的状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在API中 java.lang.Thread.State 这个枚举中给出了线程生命周期中的六种线程状态：

线程状态导致状态发生条件
NEW(新建)线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TimedWaiting(计时等待)同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Terminated(被终止)因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。
TIMED_WAITING（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。

实现一个计数器，计数到100，在IMED_WAITING每个数字之间暂停1秒，每隔10个数字输出一个字符串

public class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 100; i++) {
            if ((i) % 10 == 0) {
                System.out.println("‐‐‐‐‐‐‐" + i);
            }
            System.out.print(i); 
            try {
                Thread.sleep(1000); 
                System.out.print(" 线程睡眠1秒！\n"); 
            } catch (InterruptedException e) {
                e.printStackTrace(); 
            } 
        } 
    }
    public static void main(String[] args) {
        new MyThread().start(); 
    } 
}
  1. 进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。
  2. 为了让其他线程有机会执行，可以将Thread.sleep()的调用放在线程run()之内。这样才能保证该线程执行过程中会睡眠。
  3. sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。
  4. sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始立刻执行。

在这里插入图片描述

BLOCKED（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。

如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

这是由Runnable状态进入Blocked状态。除此，Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态。(详见补充)

在这里插入图片描述

WAITING（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

public class WaitingTest {
    public static Object obj = new Object();
    public static void main(String[] args) {
        // 演示waiting
        new Thread(new Runnable() {
            @Override 
            public void run() {
                while (true){
                    synchronized (obj){
                        try {
                            System.out.println( Thread.currentThread().getName() +"=== 象，调用wait方法，进入waiting状态，释放锁对象"); 
                            obj.wait(); //无限等待
                            //obj.wait(5000); //计时等待, 5秒 时间到，自动醒来 
                        } catch (InterruptedException e) {
                            e.printStackTrace(); 
                        }
                        System.out.println( Thread.currentThread().getName() + "=== 从waiting状 态醒来，获取到锁对象，继续执行了");
                    }
                }
            }
        },"等待线程").start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                // while (true){ //每隔3秒 唤醒一次
                try {
                    System.out.println( Thread.currentThread().getName() +"‐‐‐‐‐ 等待3秒钟"); 
                    Thread.sleep(3000); 
                } catch (InterruptedException e) {
                    e.printStackTrace(); 
                }
                synchronized (obj){
                    System.out.println( Thread.currentThread().getName() +"‐‐‐‐‐ 获取到锁对 象,调用notify方法，释放锁对象");
                    obj.notify(); 
                } 
            } 
            // } 
        },"唤醒线程").start();
    }
}

通过上述案例我们会发现，一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法 或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞 争，但更多时候你们更多是一起合作以完成某些任务。

当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入 了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入 Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

在这里插入图片描述

补充

在这里插入图片描述

经典问题

生产者、消费者：
  • 生产者线程生产数据。
  • 消费者线程消费数据。

为了使生产者和消费者能并发执行，在两者间设置一个能共享数据区域，类似仓库。

  • 生产者将生产的产品放入共享数据区中。不需要去关心消费者的行为。
  • 消费者从共享数据区中取走产品进行消费。不需要去关心生产者的行为。

显然这个过程不允许消费者到一个空仓库中取产品，也不允许生产者向一个满的仓库中放入产品。

死锁：

当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。

一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。

线程通信

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

多个线程并发执行时, 默认情况下CPU是随机切换线程的。

当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信。

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。为避免对同一共享变量的争夺。需要通过等待唤醒机制使各个线程能有效的利用资源。

等待唤醒：
public final void wait()	// 导致当前线程等待，直到被另一个线程调用该对象的notify()或notifyAll()方法唤醒。

public final void wait(long timeout)

public final void notify()	// 唤醒正在等待对象监视器的单个线程

public final void notifyAll()	// 唤醒正在等待对象监视器的所有线程

【注】：

  1. wait方法与notify方法是属于Object类的方法的。
  2. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。
  3. notify方法只唤醒一个等待（对象的）线程并使该线程开始执行。所以如果有多个线程等待一个对象，这个方法只会唤醒其中一个线程，选择哪个线程取决于操作系统对多线程管理的实现。
  4. notifyAll 会唤醒所有等待(对象的)线程，哪一个线程将会第一个处理取决于操作系统的实现。

【例】：包子铺 和 吃货

包子资源类：

public class BaoZi {
     String  pier ;
     String  xianer ;
     boolean  flag = false ; //包子资源资源状态(是否存在  包子)
}

吃货线程类：

public class ChiHuo extends Thread{
    private BaoZi bz;

    public ChiHuo(String name,BaoZi bz){
        super(name);
        this.bz = bz;
    }
    @Override
    public void run() {
        while(true){
            synchronized (bz){
                if(bz.flag == false){//没包子
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货正在吃"+bz.pier+bz.xianer+"包子");
                bz.flag = false;
                bz.notify();
            }
        }
    }
}

包子铺线程类：

public class BaoZiPu extends Thread {

    private BaoZi bz;

    public BaoZiPu(String name,BaoZi bz){
        super(name);
        this.bz = bz;
    }

    @Override
    public void run() {
        int count = 0;
        //造包子
        while(true){
            //同步
            synchronized (bz){
                if(bz.flag == true){//包子资源  存在
                    try {

                        bz.wait();

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 没有包子  造包子
                System.out.println("包子铺开始做包子");
                if(count%2 == 0){
                    // 冰皮  五仁
                    bz.pier = "冰皮";
                    bz.xianer = "五仁";
                }else{
                    // 薄皮  牛肉大葱
                    bz.pier = "薄皮";
                    bz.xianer = "牛肉大葱";
                }
                count++;

                bz.flag=true;
                System.out.println("包子造好了："+bz.pier+bz.xianer);
                System.out.println("吃货来吃吧");
                //唤醒等待线程 （吃货）
                bz.notify();
            }
        }
    }
}

测试类：

public class Demo {
    public static void main(String[] args) {
        //等待唤醒案例
        BaoZi bz = new BaoZi();

        ChiHuo ch = new ChiHuo("吃货",bz);
        BaoZiPu bzp = new BaoZiPu("包子铺",bz);

        ch.start();
        bzp.start();
    }
}

执行效果：

包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃吧
吃货正在吃冰皮五仁包子
包子铺开始做包子
包子造好了：薄皮牛肉大葱
吃货来吃吧
吃货正在吃薄皮牛肉大葱包子
包子铺开始做包子
包子造好了：冰皮五仁
吃货来吃吧
吃货正在吃冰皮五仁包子

总结

  • 线程的创建：
    • 方式1：继承Thread类
    • 方式2：实现Runnable接口，传入给Thread对象并执行。
    • 方式3：实现Callable接口 + FutureTask包装器
    • 方式4：使用ExecutorService、Callable、Future实现
  • 防止线程不安全：
    • 同步代码块：为方法中的局部代码(原子操作)加锁。
    • 同步方法：为方法中的所有代码(原子操作)加锁。
    • 锁机制
  • 线程间的通信：
    • wait() / wait(long timeout)：等待
    • notify() / notifyAll()：通知
不愿透露姓名的马建国
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java自学day2
nanshenchao的博客
02-28 919
安装完成后打开软件：设置->首选项 新建 格式：windows 默认语言Java 编码 ANSI。
AlphaControls_13.14_Stable
05-17
AlphaControls 2018 -------------------- The Library contains skinning tool for Delphi 5/6/7/2005-2010/XE-XE8, C++ Builder 6/2006-2010/XE-XE8, RAD Studio 10 Seattle, RAD Studio 10.1 Berlin, RAD ...
java-day13-多线程
lwycc2333的博客
12-22 114
13.1 概述-进程&amp;amp;amp;amp;amp;amp;amp;线程
day01_java基础
okbin1991的博客
10-07 78
typora-root-url: assets typora-copy-images-to: assets day01_java核心基础 今日目标 计算机基本概念 java语言简介 JDK 和 JRE Path环境变量配置 HelloWorld案例 常用的开发工具 注释 关键字 常量和变量 标识符 数据类型转换 ASCII码表 运算符 计...
Java Study Notes_Design in 2023（Day01~Day14）
stange1的博客
01-12 1030
注意：TreeSet强制排序，因此在你使用系统自带的类比如“string”，string的底层会封装排序方法，所以可以打印排序出的结果，而当你使用自定义类时，由于自定义类中没有封装排序类型，所以TreeSet不知道如何排序，所以会报错ClassCastExceptio类型转换异常。
day13
weixin_33978016的博客
02-22 112
　　 13.01 常见对象（StringBuffer类的概述）A.StringBuffer和String的区别 　　String是一个不可变的字符序列；StringBuffer是一个可变的字符序列13.02 常见对象（StringBuffer类的构造方法）A.StringBuffer的构造方法 　　public StringBuffer(): 无参构造 　　public Strin...
JAVAday13-14笔记
uchiha711的博客
04-18 151
StringBuffer java.lang final 线程安全的可变字符序列 类似于String的字符缓冲区 但不能修改（ex “+”号串联）但可以用特定的方法改变 String是一个不可变的字符序列 StringBuilder：不执行同步的StringBuffer 速度更快（即线程不安全） 构造 public StringBuffer（）： 无参构造方法 初始容量为16字符 如果超过 ...
day13笔记
Vainglory
11-04 200
13.01_常见对象(StringBuffer类的概述) A:StringBuffer类概述 通过JDK提供的API，查看StringBuffer类的说明 线程安全的可变字符序列 B:StringBuffer和String的区别 String是一个不可变的字符序列 StringBuffer是一个可变的字符序列 13.02_常见对象(StringBuffer类的构造方法) A:StringBu
Day13
Jerry的博客
07-31 118
13.01_常见对象(StringBuffer类的概述) A:StringBuffer类概述 通过JDK提供的API，查看StringBuffer类的说明 线程安全的可变字符序列 B:StringBuffer和String的区别 String是一个不可变的字符序列 StringBuffer是一个可变的字符序列 13.02_常见对象(StringBuffer类的构造方法) A:S...
day13笔记-string
what
01-26 149
13.01_常见对象(StringBuffer类的概述) A:StringBuffer类概述 通过JDK提供的API，查看StringBuffer类的说明 线程安全的可变字符序列 B:StringBuffer和String的区别 String是一个不可变的字符序列 StringBuffer是一个可变的字符序列 13.02_常见对象(StringBuffer类的构造方法) A:StringBu
win7 安装最后一个支持的nodejs-13.14.0.zip
06-29
版本为node-v13.14.0-x64.msi，安装可参考https://blog.csdn.net/super_DuoLa/article/details/111223818 Node.js 是一个跨平台的 JavaScript 运行时环境。 Node.js 使用高效、轻量级的事件驱动、非阻塞 I/O 模型。...
node-v13.14.0-linux-x64.tar.gz
02-20
标题 "node-v13.14.0-linux-x64.tar.gz" 提供的信息是关于一个特定版本的 Node.js 的二进制发行版，适用于 Linux 操作系统，并且是为 x64（64位）架构编译的。Node.js 是一个开源、跨平台的 JavaScript 运行环境，...
win7最后一个支持的nodejs-13.14.0版本附历史更新地址
09-05
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。 Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型。 Node 是一个让 JavaScript 运行在服务端的开发平台，它让 JavaScript 成为与PHP、Python、Perl、...
node-v13.14.0-win-x86.zip
04-17
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 ...
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 504
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 767
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1043
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
最新发布
寂夜了无痕的博客
08-24 709
linux上datax 安装以及使用
node13.14.0
12-13
node13.14.0是Node.js的一个版本。Node.js是一个基于Chrome V8引擎构建的JavaScript运行时环境，用于在服务器端运行JavaScript代码。每个Node.js版本都带来了一些新的功能、改进和修复，而node13.14.0是其中的一个特定版本。 在node13.14.0中，可能包含了一些之前版本中的Bug修复和性能优化，以及一些新的功能。这些变化有助于改善Node.js的稳定性、可靠性和性能。此外，node13.14.0还可能包含一些更新的依赖项，以确保与最新的技术和标准保持兼容性。 对于开发者来说，node13.14.0版本可能提供了一些新的API、模块和工具，使开发更加方便和高效。此外，它还可能修复了之前版本中的一些已知问题，以改进开发体验。 对于系统管理员来说，node13.14.0的发布表示他们需要更新服务器上的Node.js版本，以获得更好的性能和安全性。他们可能需要考虑与现有代码和依赖项的兼容性，并测试该版本是否适用于他们的应用程序。 总之，node13.14.0是Node.js的一个特定版本，其发布可能包含了Bug修复、性能优化、新功能和更新的依赖项。对于开发者和系统管理员来说，了解该版本的变化对于制定合适的更新和部署策略非常重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值