Java多线程(三)

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();
    }
}

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

  • 6
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值