Java多线程学习笔记(二)

本文通过售票案例探讨Java多线程的实现方式,包括实现Runnable接口和继承Thread类,并分析线程安全问题。通过引入同步代码块和`synchronized`关键字,解决了资源竞争导致的线程安全问题,提高了代码的正确性和可靠性。
摘要由CSDN通过智能技术生成

从卖票入手

先看多线程的一个经典例子:创建三个窗口卖票,总票数是100张。
先看这个代码:

package com.xzc;

class Window extends Thread{
    public Window(){

    }
    public Window(String name){
        super(name);
    }
    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(getName()+":卖票,票号为:"+ticket--);
            }else {
                break;
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");
        Window w3 = new Window("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

输出结果:
在这里插入图片描述
出现了同一张票,被多个窗口卖出的情况。这是因为我们提供的ticket是实例变量,属于每一个对象,每一个线程,这个资源不被共享。如果我们把ticket设为静态变量:

java private static int ticket = 100;
输出结果:
在这里插入图片描述
大致是共享了资源,但是还会出现一些问题!实际上这里就有线程安全问题。这里输出是因为要有一定延迟,所以从输出结果看并不是依次递减。

创建多线程

方法二:实现Runnable接口

1.创建一个实现了Runnable接口的类
2.实现Runnable类的抽象方法:run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器,创建Thread类的对象
5.通过Thread类对象调用start方法。

package com.xzc;

class MyThread implements Runnable{

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

public class Test {
    public static void main(String[] args) {
        new Thread(new MyThread(),"线程一").start();
    }

}

输出结果:
在这里插入图片描述
遍历了0~100的偶数,这里就是创建一个实现了runnable类接口的类的对象,把他作为参数传入Thread类的构造器,其实该构造器还可以有一个参数,就是线程名,我们这里直接用。这里的start有两个作用:1.启动线程。2.调用Runnable类型的target的run方法。我们可以重用这个类,再启动一个线程。

package com.xzc;

class MyThread implements Runnable{

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

public class Test {
    public static void main(String[] args) {
        new Thread(new MyThread(),"线程一").start();
        new Thread(new MyThread(),"线程二").start();
    }

}

输出结果:
在这里插入图片描述

再谈卖票问题

package com.xzc;

class Window implements Runnable{
    public Window(){}
    private int ticket;
    public Window(int ticket){
        this.ticket = ticket;
    }
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket--);
            }else {
                break;
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Window w = new Window(100);
        new Thread(w,"窗口一").start();
        new Thread(w,"窗口二").start();
        new Thread(w,"窗口三").start();
    }

}

输出结果:
在这里插入图片描述
可以发现,已经能比较好地实现资源共享了,但是这种实现方式也有线程安全问题,也会有重票的问题。但是,我们没有加static关键字,就有100张票,这是因为虽然ticket是实例变量,但是我们只有一个window对象放到构造器当参数,自然而然就是同一个ticket。

两种创建多线程方式

开发中,优先选择实现Runnable接口的方式,原因:
1.实现的方式没有类的单继承的局限性,可以让类继承一些特定的父类。
2.实现的方式更适合来处理多个线程共享数据的情况。
联系:Thread本身就实现了Runnable接口。
相同点:两种方式都要重写run方法。

线程的生命周期

在这里插入图片描述
在这里插入图片描述

线程安全

如果我们让实现runnable接口的车票程序的run方法里加个sleep

package com.xzc;

class Window implements Runnable{
    public Window(){}
    private int ticket;
    public Window(int ticket){
        this.ticket = ticket;
    }
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket--);
            }else {
                break;
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Window w = new Window(100);
        new Thread(w,"窗口一").start();
        new Thread(w,"窗口二").start();
        new Thread(w,"窗口三").start();
    }

}

输出结果:
在这里插入图片描述
输出0和-1的概率大大提升。这是因为有一张票的时候,我们t1线程进来,被阻塞,还没输出,t2进来,也被阻塞,同理t3,然后就出现了如下情况:
在这里插入图片描述
不管是重票还是错票,问题出现的原因都是当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。如何解决?当一个线程在操作ticket的时候,其他线程不能参与进来,直到该线程完成操作。这种情况,即使该线程被阻塞,也不能被改变。

同步代码块解决实现Runnable接口的线程安全问题

关键字:synchronized

synchronized(/*同步监视器*/){
	//需要被同步的代码
}
//操作共享数据的代码,即为需要被同步的代码
//同步监视器,俗称锁。任何一个类的对象,都可以充当锁。要求多个线程,共用同一把锁。
package com.xzc;

class Window implements Runnable{
    public Window(){}
    private int ticket;
    public Window(int ticket){
        this.ticket = ticket;
    }
    Object obj = new Object();
    @Override
    public void run() {

        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Window w = new Window(100);
        new Thread(w,"窗口一").start();
        new Thread(w,"窗口二").start();
        new Thread(w,"窗口三").start();
    }

}

输出结果:
在这里插入图片描述
一定注意要求多个线程,共用同一把锁,这里我们一个window对象,就一个对象obj,保证了所有线程共用一个锁。不会出现线程安全问题。
同步的好处时解决了线程安全问题,但是操作同步代码时,只能有一个线程参与,其他线程等待,相当于一个单线程过程,效率比较低。

同步代码块解决实现继承Thread类的线程安全问题

因为此时是不一样的window对象,如果和之前用一样的方法,肯定不能共用一个锁,因为每一个window对象的obj实例不一样,导致无法共用一个锁。把obj设为static即可

package com.xzc;

class Window2 extends Thread{
    public Window2(){

    }
    public Window2(String name){
        super(name);
    }
    private static int ticket = 100;
    private static final Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":卖票,票号为:" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}
public class Test2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2("窗口一");
        Window2 w2 = new Window2("窗口二");
        Window2 w3 = new Window2("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

输出结果:
在这里插入图片描述
在实现Runnable接口的锁,其实直接用this关键字即可。synchronized (this){},因为这里this指的是Window的一个对象,他是实现Runnable接口的类的对象,唯一,所以为了方便,不用new一个object,直接用this即可。但是在继承thread类的对象中,就不能用this了,因为我们new了三个对象出来,不是唯一的。有什么简便方法呢,用反射。

package com.xzc;

class Window2 extends Thread{
    public Window2(){

    }
    public Window2(String name){
        super(name);
    }
    private static int ticket = 100;
    private static final Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (Window2.class) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":卖票,票号为:" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}
public class Test2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2("窗口一");
        Window2 w2 = new Window2("窗口二");
        Window2 w3 = new Window2("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

我们在synchronized参数传入Window2的Class对象即可。synchronized (Window2.class)

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值