Java多线程（三）

- 日理万妓 2023-06-27 08:38 10阅读 0赞

**[Java多线程（一）：][Java]  
https://blog.csdn.net/Veer\_c/article/details/103842078  
[Java多线程（二）：][Java 1]  
https://blog.csdn.net/Veer\_c/article/details/103842263  
[Java多线程（三）：][Java 2]  
https://blog.csdn.net/Veer\_c/article/details/103842317  
[Java多线程（四）：][Java 3]  
https://blog.csdn.net/Veer\_c/article/details/103842602**

## 线程中的一些方法 ##

**1.线程加入**  
public final void join()  
等待该线程中止，其他线程才能继续抢着执行，因为线程执行的时候，每个线程都会抢占CPU的执行权，所以我们可以利用此方法先让一个线程执行完毕后，然后再去执行其他的线程。

package com.edu_01;
    public class MyThread extends Thread{ 
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                System.out.println(getName()+"--"+i);
            }
        }
    }
    public class Test { 
        public static void main(String[] args) { 
            //创建三个线程
            MyThread mt1 = new MyThread();
            MyThread mt2 = new MyThread();
            MyThread mt3 = new MyThread();
            //给线程起名字
            mt1.setName("刘备");
            mt2.setName("曹操");
            mt3.setName("孙权");
            //开启三个线程
            mt1.start();
            //接着让mt1这个线程设置为加入线程，其他线程就没有抢占cpu执行权的权利了，只能等待该线程执行完毕之后，才能开始抢占
            try { 
                mt1.join();
            } catch (InterruptedException e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            mt2.start();
            mt3.start();
        }
    }

**2.线程礼让**  
public static void yield():暂停当前正在执行的线程对象，并执行其他线程。  
作用：让线程间的执行更和谐一些，也就是让线程抢占CPU的概率相同一点。

package com.edu_02;
    public class MyThread extends Thread{ 
        @Override
        public void run() { 
            for (int i = 0; i < 100; i++) { 
                System.out.println(Thread.getName()+"---"+i);
                //实现线程礼让
                Thread.yield();
            }
        }
    }
    public class Test { 
        public static void main(String[] args) { 
            //创建两个线程
            MyThread mt1 = new MyThread();
            MyThread mt2 = new MyThread();
            //给线程设置名字
            mt1.setName("郭德纲");
            mt2.setName("周立波");
            //开启线程
            mt1.start();
            mt2.start();
        }
    }

**3.线程死亡**  
public final void stop():直接杀死（即终止当前运行的线程，线程不会往下执行）  
public void interrupt():直接杀死，在死前，还可以有遗言。（也就是说，线程还可以将该程序执行完）

package com.edu_03;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    public class MyThread extends Thread{ 
        @Override
        public void run() { 
            //打印一下开始执行的时间
            System.out.println("开始时间："+new SimpleDateFormat("HH:mm:ss").format(new Date()));
            //休眠10秒钟
            try { 
                Thread.sleep(10000);
            } catch (InterruptedException e) { 
                // TODO Auto-generated catch block
                //e.printStackTrace();
                System.out.println("我被杀死了");
            }
            System.out.println("结束时间："+new SimpleDateFormat("HH:mm:ss").format(new Date()));
        }
    }
    public class Test { 
        public static void main(String[] args) { 
            //创建线程对象
            MyThread mt = new MyThread();
            //开启线程对象
            mt.start();
            //在线程处于睡眠的过程中将他杀死
            try { 
                Thread.sleep(3000);
                //杀死刚刚开启的线程
                //调用stop()方法将线程直接杀死
                //mt.stop();//划了一条横线表示该方法已经过时，但是还可以使用
                //interrupt():直接杀死，在死前，还可以有遗言。
                mt.interrupt();//线程被杀死之后会将后面的代码执行完毕之后，再死去
            } catch (InterruptedException e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

**4.线程休眠**  
static void sleep(long millis) 线程睡一会，让线程休眠，一定会醒来的。

## 线程的生命周期 ##

1.新建：线程的对象调用Start（）方法  
2.就绪：线程有cpu的执行权，但是没有CPU执行资格，开始抢占CPU的执行权  
3.运行：抢占到了CPU的执行权，开始执行。（如果被其他线程抢到了执行权，则会恢复到就绪状态）  
4.有可能阻塞：线程对象调用sleep方法，wait方法，在线程睡醒之后，或者被唤醒之后，就会恢复到就绪状态，  
5.死亡：线程调用stop方法，或者调用interrupt方法，或者在线程执行完run方法后。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZlZXJfYw_size_16_color_FFFFFF_t_70]  
再来张颜色不单调的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZlZXJfYw_size_16_color_FFFFFF_t_70 1]  
**下面对线程生命周期中的 7 种状态做说明：**  
出生状态：用户在创建线程时所处的状态，在用户使用该线程实例调用 start() 方法之前，线程都处于出生状态。  
就绪状态：也称可执行状态，当用户调用 start() 方法之后，线程处于就绪状态。  
运行状态：当线程得到系统资源后进入运行状态。  
等待状态：当处于运行状态下的线程调用 Thread 类的 wait() 方法时，该线程就会进入等待状态。进入等待状态的线程必须调用 Thread 类的 notify() 方法才能被唤醒。notifyAll() 方法是将所有处于等待状态下的线程唤醒。  
休眠状态：当线程调用 Thread 类中的 sleep() 方法时，则会进入休眠状态。  
阻塞状态：如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时，线程进入就绪状态。对阻塞的线程来说，即使系统资源关闭，线程依然不能回到运行状态。  
死亡状态：当线程的 run() 方法执行完毕，线程进入死亡状态。

**提示：一旦线程进入可执行状态，它会在就绪状态与运行状态下辗转，同时也可能进入等待状态、休眠状态、阻塞状态或死亡状态。**

**使线程处于就绪状态有如下几种方法。**  
调用 sleep() 方法。  
调用 wait() 方法。  
等待输入和输出完成。

**当线程处于就绪状态后，可以用如下几种方法使线程再次进入运行状态。**  
线程调用 notify() 方法。  
线程调用 notifyAll() 方法。  
线程调用 intermpt() 方法。  
线程的休眠时间结束。  
输入或者输出结束。

**线程间通信(生产消费者问题)：不同类型线程针对同一个资源的操作**  
1.系统不仅要卖票还要入票，每次生产一张票，就会卖出去一张票，称为单生产单消费问题。  
2.不仅要卖肉夹馍还要生产肉夹馍，可以利用多个线程去生产肉夹馍，然后利用多个线程去出售，称为多生产多消费问题。

**案例：以给学生设置和获取姓名和年龄为例，演示线程通信问题  
线程间通讯：**  
资源：Student  
设置数据线程：SetThread  
获取数据线程：GetThread  
测试类：StudentDemo

package com.edu_04;
    public class Student { 
        String name;
        int age;
    }
    public class SetThread implements Runnable{ 
        private Student s;
        private int x=0;
        public SetThread(Student s){ 
            this.s = s;
        }
        @Override
        public void run() { 
            //给学生对象设置姓名和年龄
            //Student s = new Student();
            while (true) { 
                synchronized (s) { 
                    if (x%2==0) { 
                        s.name = "刘嘉玲";
                        s.age = 50;
                    }else { 
                        s.name = "陈冠希";
                        s.age = 35;
                    }
                    x++;
                }
            }
        }
    }
    public class GetThread implements Runnable{ 
        private Student s;
    
        public GetThread(Student s){ 
            this.s = s;
        }
        @Override
        public void run() { 
            //获取线程，获取学生对象的姓名和年龄
            //Student s = new Student();
            while (true) { 
                synchronized (s) {   
                    System.out.println(s.name+"--"+s.age);  
                }
            }
        }
    }
    public class StudentDemo { 
        public static void main(String[] args) { 
            //创建一个学生对象
            Student s = new Student();
            //创建设置和获取线程，并开启线程
            SetThread st = new SetThread(s);
            GetThread gt = new GetThread(s);
            Thread t1 = new Thread(st);
            Thread t2 = new Thread(gt);
            //开启线程
            t1.start();
            t2.start();
        }
    }

问题1：控制台出现的结果是:null—0  
因为我们在在创建对象的时候，setThread（）和getThread（）的对象不是同一个，所以在输出的时候，因为setThread()还没有设置对象，所以我在传递参数的时候可以自己创建构造方法，让这个参数一致  
设置和获取线程使用的学生资源不是同一个，把资源作为构造参数传递即可。  
问题2：  
相同的数据出现了多次，CPU的一点点时间就足够我们的程序执行很多次  
数据出现了问题(数据安全问题)  
a:是否是多线程环境 是  
b:是否有共享数据 是  
c:是否有多条语句操作共享数据 是  
既然我们知道它是出现了数据安全问题，我们就应该来解决它。  
如何解决呢?加锁  
问题3：加了锁以后，数据还是有问题  
A:多个线程都要加锁  
B:多个线程加的锁必须是同一把锁  
因为，线程在执行的时候，每个线程的都会有抢占的随机性，所以输出的时候没有那么和谐，而且会出现错误的数据，出现线程不安全问题，所以我们要给线程加锁，保证线程数据安全，我们可以用等待，唤醒机制保证数据的和谐

**将上述代码使用等待唤醒机制改进，实现礼让效果**

package com.edu_05;
    public class Student { 
        String name;
        int age;
        boolean flag;//在这里可以作为对象的一个标记，如果是false说明该对象没有数据，如果是true说明该对象有数据
    }
    public class SetThread implements Runnable{ 
        private Student s;
        private int x = 0;
    
        public SetThread(Student s){ 
            this.s = s;
        }
        @Override
        public void run() { 
            while (true) { 
                synchronized (s) { 
                    //判断该对象此时有没有数据
                    if (s.flag) { 
                        //等待
                        try { 
                            s.wait();//设置线程等待，释放锁s
                        } catch (InterruptedException e) { 
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    if (x%2==0) { 
                        s.name = "刘嘉玲";
                        s.age = 50;
                    }else { 
                        s.name = "冠希";
                        s.age = 35;
                    }
                    x++;//x=1
                    //此时对象有数据了
                    s.flag = true;
                    s.notify();//如果有等待的线程就唤醒，如果没有等待的线程，则没有任何效果
                }//在此时释放锁对象s
            }
        }
    }
    public class GetThread implements Runnable{ 
        private Student s;
        public GetThread(Student s){ 
            this.s = s;
        }
        @Override
        public void run() { 
            while (true) { 
                synchronized (s) { 
                    //判断对象有没有数据
                    if (!s.flag) { 
                        //等待设置线程给对象设置数据
                        try { 
                            s.wait();//获取线程处于等待状态，释放锁对象s,在哪里跌倒在哪里爬起来
                        } catch (InterruptedException e) { 
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    System.out.println(s.name+"--"+s.age);//刘嘉玲--50
                                                          //冠希--35
                                                          //刘嘉玲--50
                    //当获取线程从学生对象中获取了数据之后，我们就默认他已经没有数据了，此时我们应该
                    //继续让设置线程继续给学生对象设置信息
                    s.flag = false; 
                    s.notify();
                }
            }
        }
    }
    public class StudentDemo { 
        public static void main(String[] args) { 
            //创建学生对象
            Student s = new Student();
            //创建设置线程和获取线程
            SetThread st = new SetThread(s);
            GetThread gt = new GetThread(s);
            Thread t1 = new Thread(st);
            Thread t2 = new Thread(gt);
            //开启线程
            t1.start();
            t2.start();
        }
    }

**将上述代码继续优化：可以将上述代码封装成方法**  
1.私有化Student类的成员变量  
2.在类的内部提供设置和获取的同步方法

public class Student { 
        //块编辑(alt+shift+a):在使用块编辑的时候，一定要将输入法切换到英文输入法，不然会出问题
        private String name;
        private int age;
        private boolean flag;//在这里可以作为对象的一个标记，如果是false说明该对象没有数据，如果是true说明该对象有数据
        //提供公共的方法设置信息
        public synchronized void setInfo(String name,int age){ 
            if (this.flag) { 
                //等待
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //没有值的话，在这里给对对象设置数据
            this.name = name;
            this.age = age;
            //更改标记，唤醒获取线程获取数据
            this.flag = true;
            this.notify();
        }
        //提供公共的方法获取信息
        public synchronized void getInfo(){ 
            if (!this.flag) { 
                //没有值
                try { 
                    this.wait();
                } catch (InterruptedException e) { 
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //有数据，取数据
            System.out.println(this.name+"--"+this.age);
            //取完数据之后，就没有数据了
            this.flag = false;
            this.notify();
        }
    }
    public class SetThread implements Runnable{ 
        private Student s;
        private int x = 0;
        public SetThread(Student s){ 
            this.s = s;
        }
        @Override
        public void run() { 
            while (true) { 
                    if (x%2==0) { 
                        s.setInfo("刘嘉玲", 50);
                    }else { 
                        s.setInfo("陈冠希", 35);
                    }
                    x++;//x=1
                }
        }
    }
    public class GetThread implements Runnable{ 
        private Student s;
        public GetThread(Student s){ 
            this.s = s;
        }
        @Override
        public void run() { 
            while (true) { 
                s.getInfo();
            }
        }
    }
    public class StudentDemo { 
        public static void main(String[] args) { 
            //创建学生对象
            Student s = new Student();
            //创建设置线程和获取线程
            SetThread st = new SetThread(s);
            GetThread gt = new GetThread(s);
            Thread t1 = new Thread(st);
            Thread t2 = new Thread(gt);
            //开启线程
            t1.start();
            t2.start();
        }
    }

[Java]: https://blog.csdn.net/Veer_c/article/details/103842078
[Java 1]: https://blog.csdn.net/Veer_c/article/details/103842263
[Java 2]: https://blog.csdn.net/Veer_c/article/details/103842317
[Java 3]: https://blog.csdn.net/Veer_c/article/details/103842602
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZlZXJfYw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200105134607264.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZlZXJfYw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZlZXJfYw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200105134727247.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1ZlZXJfYw==,size_16,color_FFFFFF,t_70