Java多线程笔记

介绍

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期
　　>如:运行中的QQ，运行中的MP3播放器
　　>程序是静态的，进程是动态的
　　>进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小；
一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

为什么需要多线程

众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献。

线程状态转换

新建(New)

创建后尚未启动。

就绪(Runnable)

可能正在运行，也可能正在等待 CPU 时间片。

包含了操作系统线程状态中的 Running 和 Ready。

阻塞(Blocking)

等待获取一个排它锁，如果其线程释放了锁就会结束此状态。

无限期等待(Waiting)

等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。

限期等待(Timed Waiting)

无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。

调用 Thread.sleep() 方法使线程进入限期等待状态时，常常用“使一个线程睡眠”进行描述。

调用 Object.wait() 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。

睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。

阻塞和等待的区别在于，阻塞是被动的，它是在等待获取一个排它锁。而等待是主动的，通过调用 Thread.sleep() 和 Object.wait() 等方法进入。

死亡(Terminated)

可以是线程结束任务之后自己结束，或者产生了异常而结束。

线程使用方式

有三种使用线程的方法:

• 实现 Runnable 接口；
• 实现 Callable 接口；
• 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

继承 Thread 类

public class ThreadTest {
    /**
     * 多线程的创建，
     * 方式一：
     * 1.继承与Thread类
     * 2.重写Thread类的run方法->将此线程执行的操作声明在run中
     * 3.创建Thread类的子类
     * 4.通过此对象调用start
     */
    public static void main(String[] args) {
//        创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //不能通过run方法开启线程，因为还会在主线程中运行，应该使用start方法开启线程
        //不能通过调用两次start方法来开启两个子线程
        t1.start();

        //可以通过再创建一个对象来实现

        for (int i=0;i<1000;i++){
            if (i%2!=0){
                System.out.println(i+"****");
            }
        }
    }

}
class MyThread extends Thread{
    @Override
    public void run() {
       for (int i=0;i<1000;i++){
           if (i%2==0){
               System.out.println(i);
           }
       }
    }
}

　　

    /**
     * 方式二：
     * 匿名子类创建，针对只调用一次的线程
     */
    public static void main(String[] args) {

        MyThread1 myThread1 = new MyThread1();
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();

        //通过匿名子类实现调用：特点只需要调用一次的子线程
        new Thread(){
            @Override
            public void run() {
                for (int i=0;i<1000;i++){
                    if (i%3==0){
                        System.out.println(Thread.currentThread().getName()+"***"+i);
                    }
                }
            }
        }.start();
    }

}

class MyThread1 extends Thread{
    @Override
    public void run() {
       for (int i=0;i<100;i++){
           if (i%2!=0){
               System.out.println(Thread.currentThread().getName()+"***"+i);

           }
       }
    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+"***"+i);
            }
        }
    }
}

实现 Runnable 接口

package com.atguigu.juc.runnable;

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

public class TestThread {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread myThread = new MyThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(myThread);
        //5，通过Thread类的对象调用start()
        t1.start();
    }
}
//1.创建一个实现Runnable接口的类
class MyThread implements Runnable{
//2.实现类去实现Runnable中的抽象方法: run( )
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

　　　

实现 Callable 接口

 

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 创建线程方式三：实现Callable接口
 *如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
 * 1. calL()可以有返回值的。
 * 2. call可以抛出异常，被外面的操作捕获，获取异常的信总3. callable是支持泛型的
 *
 */
public class ThreadNew {
    public static void main(String[] args) {
        // 3.创建Callable接口实现类的对象
        NumberThread numberThread = new NumberThread();
        //4.将此callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask<Integer> futureTask = new FutureTask<>(numberThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取线程返回值
            //get()返回值即为FutureTask构造器参数callable实现类重写的calL()的返回值。
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//1.创建一个实现CaLlabLe的实现类
class NumberThread implements Callable<Integer>
{
//2.实现caLl方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int i=0;i<=100;i++){
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":::"+i);
                sum+=i;
            }
        }
        return sum;
    }
}

　线程池　

package com.atguigu.juc.pool;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 *好处:
 * 1.提高响应速度（减少了创建新线程的时间)
 * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建)3.便于线程管理
 * corePoolsize:核心池的大小maximumPoolsize:最大线程数
 * keepALiveTime:线程没有任务时最多保持多长时间后会终止
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1．提供指定线程数量的线程池

        ExecutorService pool = Executors.newFixedThreadPool(10);

//        ThreadPoolExecutor service1= (ThreadPoolExecutor) pool;
//        service1.setCorePoolSize(15);
        System.out.println(pool.getClass());
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        pool.execute(new NumberThread());//适合适用于Runnable
        pool.execute(new NumberThread1());
        //pool.submit();//适合使用于calLable
        //3.关闭连接池
        pool.shutdown();
    }
}
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);

            }
        }
    }
}

　　

线程常见方法

package com.atguigu.juc.tset01;

/**
 * 1.yield():释放当前cpu的执行权
 *
 * 2.start():启动当前线程;调用当前线程的run()
 *
 * 3.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 *
 * 4.getName()∶获取当前线程的名字
 *
 * 5.setName():设置当前线程的名字
 *
 * 6.currentThread():静态方法，返回执行当前代码的线程
 *
 * 7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
 *
 * 8.sleep():让当前线程"睡眠”指定的毫秒。在指定的毫秒时间内，当前线程是阻塞状态。
 *
 */
public class MyThreatTest {
    public static void main(String[] args) {


        TestMyThread t1 = new TestMyThread();
            t1.start();
        new Thread(){
            @Override
            public void run(){
                for (int i=0;i<100;i++){
                    if (i%2==0){
                        try {
                            sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "子线程" + i);
                        yield();
                    }

                }
            }
        }.start();

        for (int i=0;i<100;i++){
            if (i%3==0){
                System.out.println(Thread.currentThread().getName() + "main方法" + i);
            }
            if (i==20){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class TestMyThread extends Thread{
    @Override
    public void run(){
        for (int i=0;i<100;i++){
            if (i%5==0){
                System.out.println(Thread.currentThread().getName() + "2222222222222子线程" + i);

            }

        }
    }
}

　　

synchronized锁机制

• 一把锁只能同时被一个线程获取，没有获得锁的线程只能等待；
• 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁
• synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

同步代码---Runnable接口方式

/**
 *方式一:同步代码块
 * synchronized(同步监视器){
 *          //需要被同步的代码
 *  }
 * 说明:
 * 1.操作共享数据的代码，即为需要被同步的代码
 * 2.共享数据:多个线程共同操作的变量
 * 3.同步监视器，俗称:锁。任何一个类的对象都可以作为索
 * 4.在Java中，我们通过同步机制，来解决线程的安全问题。
 * 补充:在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
 * 方式二:同步方法
 *  如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 * 5.同步的方式，解决了线程的安全问题。---好处
 * 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
 */
public class WindowToRunnable {
    public static void main(String[] args) {
        Window2 window2 = new Window2();

        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{
//这里不用加static,因为调用的对象只有一个
    private  int ticket=100;
    @Override
    public void run() {

            while (true) {
                synchronized (this.getClass()){
                if (ticket > 0) {
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                    System.out.println(Thread.currentThread().getName() + "买票,票号:" + ticket);
                    ticket--;
                }
            }
        }
    }
}

　　同步方法--Runnable接口方法

package com.atguigu.juc.bookPage;

/**
 * 使用同步方法解决实现Runnable接口的线程安全问题
 * 关于同步方法的总结:
 * 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
 * 2．非静态的同步方法，同步监视器是: this
 * 静态的同步方法，同步监视器是:当前类本身
 */

public class WindowExtSynn {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window4 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();

        }
    }

    private static synchronized void show() {
        if (ticket>0){

            System.out.println(Thread.currentThread().getName()+":买票：票号为"+ticket);
            ticket--;
        }
    }
}

　　同步方法---继承方法

package com.atguigu.juc.bookPage;

/**
 * 使用同步方法解决实现Runnable接口的线程安全问题
 * 关于同步方法的总结:
 * 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
 * 2．非静态的同步方法，同步监视器是: this
 * 静态的同步方法，同步监视器是:当前类本身
 */

public class WindowExtSynn {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

class Window4 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();

        }
    }

    private static synchronized void show() {
        if (ticket>0){

            System.out.println(Thread.currentThread().getName()+":买票：票号为"+ticket);
            ticket--;
        }
    }
}

　　死锁

示例：两个线程都拿到第一层锁的key，然后都需要第二层锁的key，但key在对方手中，而方法没有执行完，都不可能释放key，互相僵持。

import static java.lang.Thread.sleep;

public class TestSyn {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    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() {
                synchronized (s2) {
                    s1.append("c");
                    s2.append("3");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1) {
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

　　Lock锁机制

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三: Lock锁--- JDK5.0新增
 *
 * synchronized 与Lock的异同?
 * 相同:二者都可以解决线程安全问题
 * 不同: synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
 *      Lock需要手动的启动同步(Lock() )，同时结束同步也需要手动的实现(unlock())
 *
 */
public class LockTest {
    public static void main(String[] args) {
        Window6 window6 = new Window6();
        Thread t1 = new Thread(window6);
        Thread t2 = new Thread(window6);
        Thread t3 = new Thread(window6);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}
class Window6 implements Runnable{
    private int ticker=100;

    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticker>0){
                    System.out.println(Thread.currentThread().getName()+"买票：票号："+ticker);

                    ticker--;
                }else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

　　银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1e00，存3次。每次存完打印账户余额。

/**
 * 银行有一个账户。
 * 有两个储户分别向同一个账户存3000元，每次存1e00，存3次。每次存完打印账户余额。
 * 分析:
 * 1.是否是多线程问题?是，两个储户线程
 * 2.是否有共享数据?有，账户（或账户余额).
 * 3.是否有线程安全问题?有
 * 4.需要考虑如何解决线程安全问题?同步机制:有三种方式。
 */
public class AccountTest {

    public static void main(String[] args) {
        Account account = new Account(0);
        Customer c1 = new Customer(account);
        Customer c2 = new Customer(account);
        c1.setName("A");
        c2.setName("B");
        c1.start();
        c2.start();
    }
}
class Account{
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }
    //存钱
    public synchronized void deposit(double amt){
        //synchronized (this.getClass()) {
            if (amt>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance+=amt;
                System.out.println(Thread.currentThread().getName()+"存钱成功，余额为"+balance);
            }
       // }
    }
}
class Customer extends Thread{
    private Account acc;
    public Customer(Account acc){
        this.acc=acc;
    }

    @Override
    public void run() {
        for (int i=0;i<30;i++){
            acc.deposit(1000);
        }
    }
}

　　

A存钱成功，余额为1000.0
B存钱成功，余额为2000.0
B存钱成功，余额为3000.0
B存钱成功，余额为4000.0
A存钱成功，余额为5000.0
A存钱成功，余额为6000.0

　　线程通信

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。

　    就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。

　　于是我们引出了等待唤醒机制：（wait()、notify()）

　　就是在一个线程进行了规定操作后，就进入等待状态（wait）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify）；

（1）wait()方法：

　　  线程调用wait()方法，释放它对锁的拥有权，同时他会在等待的位置加一个标志，为了以后使用notify()或者notifyAll()方法  唤醒它时，它好能从当前位置获得锁的拥有权，变成就绪状态，

　　  要确保调用wait()方法的时候拥有锁，即，wait()方法的调用必须放在synchronized方法或synchronized块中。  在哪里等待被唤醒时，就在那里开始执行。

（2）notify/notifyAll()方法：

　　notif()方法：notify()方法会唤醒一个等待当前对象的锁的线程。唤醒在此对象监视器上等待的单个线程。

　　notifAll()方法：notifyAll（）方法会唤醒在此对象监视器上等待的所有线程。

　　当执行notify/notifyAll方法时，会唤醒一个处于等待该 对象锁 的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。

　　从这里可以看出，notify/notifyAll()执行后，并不立即释放锁，而是要等到执行完临界区中代码后，再释放。故在实际编程中，我们应该尽量在线程调用notify/notifyAll()后，立即退出临界区。即不要在notify/notifyAll()后面再写一些耗时的代码。

 

1.wait( )，notify( )，notifyAlL()三个方法必须使用在同步代码块或同步方法中。
2.wait()，notify( )，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器否则，会出现iLlegaLMonitorstateException异常
3.wait()，notify( )，notifyAlL()三个方法是定义在java.Lang.object类中。

 sleep和wait异同

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

不同点：
1）两个方法声明的位置不同: Thread类中声明sLeep() , object类中声明wait()
2）调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法

3）关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sLeep()不会释放锁，wait（）会释放锁。

package com.atguigu.juc.tongxin;

/**
 * 线程通信的例子:使用两个线程打印1-100。线程1，线程2交替打印
 */
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        Thread t3 = new Thread(number);
        t1.setName("窗口1");
        t2.setName("窗口2");

        t1.start();
        t2.start();

    }
}
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方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {

                    }
                }else {
                    break;
                }
            }
        }
    }
}

　　

生产者/消费者问题

/**
 * 线程通信的应用:经典例题:生产者/消费者问题
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
 * 店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员会叫生产者停一下，
 * 如果店中有空位放产品了再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，
 * 如果店中有产品了再通知消费者来取走产品。
 *
 * 分析:
 * 1．是否是多线程问题?是，生产者线程，消费者线程
 * 2．是否有共享数据?是，店员或产品
 * 3. 如何解决线程的安全问题?同步机制,有三种方法
 * 4. 是否涉及线程的通信?是
 */
public class productTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);
        Consumer c1 = new Consumer(clerk);
        p1.setName("生产者1");
        c1.setName("消费者1");
        p1.start();
        c1.start();


    }
}

class Clerk{
private int produceProduct=0;
    //生产产品
    public synchronized void produceProduck() {

        if (produceProduct<20){

            produceProduct++;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            notify();
            System.out.println(Thread.currentThread().getName()+"开始生产第"+produceProduct+"个产品");
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //消费产品
    public synchronized void cunsumeProduck() {

        if(produceProduct>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"开始消费第"+produceProduct+"个产品");
            produceProduct--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
class Producer extends Thread{//生成者
    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+"开始生产产品....");
        while (true){
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduck();
        }

    }
}
class Consumer extends Thread{//消费者
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+"开始消费产品....");
        while (true){
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.cunsumeProduck();
        }
    }
}