全站资源开放下载,感谢广大网友的支持
链接失效请移步职业司平台
非盈利平台

非盈利平台

只为分享一些优质内容

Java帮帮-微信公众号

Java帮帮-微信公众号

将分享做到极致

微信小程序

微信小程序

更方便的阅读

职业司微信公众号

职业司微信公众号

实时动态通知

安卓APP

安卓APP

我们从此不分开

程序员生活志-公众号

程序员生活志-公众号

程序员生活学习圈,互联网八卦黑料

支付宝赞助-Java帮帮社区
微信赞助-Java帮帮社区

Java多线程入门(一)[云图智联]

5
发表时间:2020-07-03 12:31

免费学习视频欢迎关注云图智联:https://e.yuntuzhilian.com/

Java多线程入门
线程同步
为什么要线程同步?
使用多线程可以让我们的程序更加充分的利用CPU,提高程序的效率,但是同时也带来了一些问题。多线程在使用线程公共资源的时候往往会遇到问题。
想象一下这样一个情景:一个商店中有三件商品,但是四个顾客同时来购买商品,他们都能买到商品吗?

我们用代码模拟一下:

public class Test{
       public static void main(String[] args) {
             //创建一个商店
             Store store = new Store();
             //创建四个共用一个商店的顾客线程
             CustomerThread ct1 = new CustomerThread("顾客1",store);
             CustomerThread ct2 = new CustomerThread("顾客2",store);
             CustomerThread ct3 = new CustomerThread("顾客3",store);
             CustomerThread ct4 = new CustomerThread("顾客4",store);
             //启动四个线程
             ct1.start();
             ct2.start();
             ct3.start();
             ct4.start();
       }
}
//商店类
class Store {
       //剩余商品数量
       static int goodsNumble = 3;
       public Store(){
       }
       //出售一件商品
void sell() {
        //先判断商品是否售完
             if(goodsNumble<=0)
                    System.out.println("商店:出售失败,商品卖完了");
             else {
                    System.out.println("此时还有"+goodsNumble+"件商品");
                    goodsNumble--;
                    System.out.println("售出一件商品,商品数量减1");
                    }
       }
}
class CustomerThread extends Thread{
       private Store store;
       public CustomerThread(String name,Store store) {
             // TODO 自动生成的构造函数存根
             setName(name);
             this.store = store;
       }
       @Override
       public void run() {
             buy();
       }
       //购买商品,调用store的sell方法
       public void buy() {
             store.sell();
       }
}

运行结果


从上面的代码和运行结果我们可以看到,因为顾客几乎是同时到达商店的,所以他们到的时候商品的水量都是3,于是商店给每一位顾客都出售了一件商品。这显然不是我们想要的结果。然后我们给Store类的sell()方法加上synchronized关键字,局部修改如下:


运行结果:


可以看到在我们给sell方法使用了synchronized关键字后Stroe会按照一定的顺序来为顾客服务,这就是synchronized方法的效果.当当前线程使用synchronized方法时,会给当前对象(store)上锁,上锁后其他线程在使用相同对象的方法时进入阻塞,需等待此线程中的该方法结束,才能继续运行。

线程同步的三个方法
为了介绍线程同步的三个方法,我们先来看一下这样一个场景:有一个房间,房间里居住着四个人,四个人共用着房间里的一部电话。每个人都可以在任何时候使用电话,但是如果他们在同一时间都来使用这部电话又会发生什么呢?

我们用代码模拟一下:

public class SynchronizedMethod {
       public static void main(String[] args) {
             Room r = new Room();
             //创建并启动4个学生线程
             StudentThread s1   =new StudentThread("s1",r);
             StudentThread s2   =new StudentThread("s2",r);
             StudentThread s3   =new StudentThread("s3",r);
             StudentThread s4   =new StudentThread("s4",r);
             s1.start();
             s2.start();
             s3.start();
             s4.start();
       }
}

class Room {
       public Phone phone;
       public Room() {
             // TODO 自动生成的构造函数存根
             phone = new Phone();
       }       
}

class Phone{
       static final int FREE = 1,BUSY = 0;
       //电话的状态
       private int status=FREE;
       public Phone() {
       
       }
       //判断电话是否空闲
       public boolean   isFree() {
             return status==FREE;
       }
       //打电话,半秒后挂断,为了打印电话使用者的名字,我们传入一个参数
       public void call(String user) {
             if(!isFree()) {
                    System.out.println("有人正在使用电话哦");
                    return;
             }
             status = BUSY;
             System.out.println(user+"打出了电话...");
             try {
                    Thread.sleep(500);
                    hangUp(user);
             } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
             }
       }
       //挂电话
       public   void hangUp(String user) {
             status = Phone.FREE;
             System.out.println(user+"挂断了电话...");
       }
}

class StudentThread extends Thread{
       private Room room;
       public StudentThread(String name,Room room) {
             setName(name);
             this.room = room;
       }
       @Override
       public void run() {
                    this.room.phone.call(getName());
       }
}


运行结果


我们可以发现当线程s1使用了对象phonecall方法的时候,其他三个线程仍然使用了call方法。这就是线程不同步的效果。接下来我们分别用三种方法实现线程同步。

synchronized方法
将Phone类的call声明为sychronized方法(在call方法前面加上关键字即可),修改部分代码如下:

运行结果


synchronized块
在call函数内添加synchronized代码块,此方法与上一方法相比,优点在于你不需将整个方法都变成同步的,只需把关键代码块变为同步即可,修改部分代码如下:

运行结果


Lock

运行结果


线程死锁
线程死锁,是指多个线程在使用公共资源时各占了资源的一部分,导致每个线程都等待其他线程释放资源才能完成工作,最终导致每个线程都无法完成工作,互相卡死。
想象一下这样的情景:上学时,你和你的同桌共用一个笔记本和一支钢笔,只是你的老师讲到了一个要点,于是你顺势抢到了钢笔,而你的同桌拿到了笔记本,谁也不肯让步,于是谁也无法完成笔记。
我们用代码模拟一下:

public class DeadLock {
       public static void main(String[] args) {
             Stationery stationery = new Stationery();
             //p1 takeNotes时先获取并锁定本子,然后再试图获取笔
             Person p1 = new Person("p1",stationery) {
                    @Override
                    public void takeNotes() {
                           synchronized (stationery.notebook) {
                                 getNotebook();
                                 synchronized (stationery.pen) {
                                        getPen();
                                 }
                           }
                    }
             };

             //p2 takeNotes时先获取并锁定笔,然后再试图获取本子
             Person p2 = new Person("p2",stationery) {
                    @Override
                    public void takeNotes() {
                           synchronized (stationery.pen) {
                                 getPen();
                                 synchronized (stationery.notebook) {
                                        getNotebook();
                                 }
                           }
                    }
             };
             p1.start();
             p2.start();
       }
}

//文具类(共用资源)
class Stationery{
       //笔
       public static Pen pen = new Pen();
       //笔记本
       public static Notebook notebook= new Notebook();
}

class Pen{
       
}

class Notebook{

}
abstract class Person extends Thread{
       Stationery stationery;
       public Person(String name,Stationery s) {
             // TODO 自动生成的构造函数存根
             setName(name);
             stationery = s;
       }
       //获取笔
       Pen getPen() {
                    System.out.println(getName()+":我拿打笔了");
                    try {
                           Thread.sleep(1);
                    } catch (InterruptedException e) {
                           // TODO 自动生成的 catch 块
                           e.printStackTrace();
                    }
             return stationery.pen;
       };
       //获取本子
       Notebook getNotebook() {
                    System.out.println(getName()+":我拿打笔记本了");
                    try {
                           Thread.sleep(1);
                    } catch (InterruptedException e) {
                           // TODO 自动生成的 catch 块
                           e.printStackTrace();
                    }
             return stationery.notebook;
       };
       //抽象方法
       public abstract void takeNotes();
       @Override
       public   void run() {
             takeNotes();
       };
}

运行结果(程序并没有结束而是一直卡住无法往下运行)


线程的生命周期


新建态 :Thread t = new Thread(),线程对象被创建,此时还没有使用start()方法,启动线程
就绪状态 :t.start()后进入就绪状态,但具体什么时候运行取决于CPU的调度
运行态:线程占用CPU运行
阻塞态:线程在运行时,使用了Thread.sleep()或者进行I/O操作等不在占用CPU,则由运行态进入阻塞态,待事件结束再进入就绪态
t.stop()线程结束,进入终止态(消亡状态)

了解更多相关经验的知识,可以关注云图智联


免费学习视频欢迎关注云图智联:https://e.yuntuzhilian.com/

Java帮帮学习群生态

Java帮帮学习群生态

总有一款能帮到你

Java学习群

Java学习群

与大牛一起交流

大数据学习群

大数据学习群

在数据中成长

九点编程学习群

九点编程学习群

深夜九点学编程

python学习群

python学习群

人工智能,爬虫

测试学习群

测试学习群

感受测试的魅力

Java帮帮生态承诺

Java帮帮生态承诺

一直坚守,不负重望

初心
勤俭
诚信
正义
分享
友链交换:加帮主QQ2524138991 留言即可 24小时内答复  
业司
满吉教育资讯
会员登录
获取验证码
登录
登录
我的资料
留言
回到顶部