Java多线程（三）

最新推荐文章于 2023-12-11 23:17:09 发布

Veer_c

最新推荐文章于 2023-12-11 23:17:09 发布

阅读量6.8k

点赞数 6

分类专栏：成长之路文章标签： java 多线程 thread 线程礼让 Java多线程细节与要点

本文链接：https://blog.csdn.net/Veer_c/article/details/103842317

版权

成长之路专栏收录该内容

39 篇文章 2 订阅

订阅专栏

Java多线程（一）：
https://blog.csdn.net/Veer_c/article/details/103842078
Java多线程（二）：
https://blog.csdn.net/Veer_c/article/details/103842263
Java多线程（三）：
https://blog.csdn.net/Veer_c/article/details/103842317
Java多线程（四）：
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方法后。
在这里插入图片描述
再来张颜色不单调的。

下面对线程生命周期中的 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();
    }
}

Veer_c

关注

6
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java多线程（三）

线程中的一些方法1.线程加入public final void join()等待该线程中止，其他线程才能继续抢着执行，因为线程执行的时候，每个线程都会抢占CPU的执行权，所以我们可以利用此方法先让一个线程执行完毕后，然后再去执行其他的线程。package com.edu_01;public class MyThread extends Thread{ @Override ...
复制链接

扫一扫