[多线程]同步代码块处理实现Runnable及继承Thread类的线程安全问题

最新推荐文章于 2024-07-27 13:31:57 发布

反方向的钟c

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量236

点赞数 2

分类专栏： Java # 多线程文章标签： java

本文链接：https://blog.csdn.net/ivynico/article/details/124303590

版权

Java 同时被 2 个专栏收录

85 篇文章 1 订阅

订阅专栏

多线程

10 篇文章 0 订阅

订阅专栏

以多窗口售票为例:

创建三个窗口卖票，总票数为100张 使用实现Runnable接口的方式

class WindowThread implements Runnable{
    private int ticket = 100;

    @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);
                ticket--;
            }else {
                break;
            }
            
        }

    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        WindowThread w = new WindowThread();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
        
    }
}

创建三个窗口卖票，总票数为100张 使用继承Thread类的方式

class Window extends Thread{
    private static int ticket = 100;
    @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);
                ticket--;
            }else {
                break;
            }
        }

    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
        
    }
}

两种方式都存在重票或错票的线程安全问题:

窗口1：卖票，票号为：100
窗口3：卖票，票号为：100
窗口2：卖票，票号为：100
窗口1：卖票，票号为：97
窗口3：卖票，票号为：97
窗口2：卖票，票号为：95
窗口2：卖票，票号为：94
窗口3：卖票，票号为：94
窗口1：卖票，票号为：94
窗口2：卖票，票号为：91
窗口3：卖票，票号为：91
窗口1：卖票，票号为：89
窗口3：卖票，票号为：88
窗口2：卖票，票号为：88
窗口1：卖票，票号为：86
窗口1：卖票，票号为：85
窗口2：卖票，票号为：85
窗口3：卖票，票号为：85
窗口2：卖票，票号为：82
窗口1：卖票，票号为：82
窗口3：卖票，票号为：80
窗口2：卖票，票号为：79
窗口1：卖票，票号为：78
窗口3：卖票，票号为：77
窗口2：卖票，票号为：76
窗口1：卖票，票号为：76
窗口3：卖票，票号为：74
窗口2：卖票，票号为：73
窗口1：卖票，票号为：73
窗口3：卖票，票号为：71
窗口2：卖票，票号为：70
窗口1：卖票，票号为：69
窗口3：卖票，票号为：68
窗口2：卖票，票号为：67
窗口1：卖票，票号为：66
窗口3：卖票，票号为：65
窗口2：卖票，票号为：64
窗口1：卖票，票号为：63
窗口3：卖票，票号为：62
窗口2：卖票，票号为：61
窗口1：卖票，票号为：60
窗口3：卖票，票号为：59
窗口2：卖票，票号为：58
窗口1：卖票，票号为：57
窗口3：卖票，票号为：56
窗口2：卖票，票号为：55
窗口1：卖票，票号为：54
窗口3：卖票，票号为：53
窗口2：卖票，票号为：52
窗口1：卖票，票号为：51
窗口3：卖票，票号为：50
窗口2：卖票，票号为：49
窗口1：卖票，票号为：48
窗口3：卖票，票号为：47
窗口2：卖票，票号为：46
窗口1：卖票，票号为：45
窗口3：卖票，票号为：44
窗口2：卖票，票号为：43
窗口1：卖票，票号为：42
窗口3：卖票，票号为：41
窗口2：卖票，票号为：40
窗口1：卖票，票号为：39
窗口3：卖票，票号为：38
窗口2：卖票，票号为：37
窗口1：卖票，票号为：36
窗口3：卖票，票号为：35
窗口2：卖票，票号为：34
窗口1：卖票，票号为：33
窗口3：卖票，票号为：32
窗口2：卖票，票号为：31
窗口1：卖票，票号为：30
窗口3：卖票，票号为：29
窗口2：卖票，票号为：28
窗口1：卖票，票号为：27
窗口3：卖票，票号为：26
窗口2：卖票，票号为：25
窗口1：卖票，票号为：24
窗口3：卖票，票号为：23
窗口2：卖票，票号为：22
窗口1：卖票，票号为：21
窗口3：卖票，票号为：20
窗口2：卖票，票号为：19
窗口1：卖票，票号为：18
窗口3：卖票，票号为：17
窗口2：卖票，票号为：16
窗口1：卖票，票号为：15
窗口3：卖票，票号为：14
窗口2：卖票，票号为：13
窗口1：卖票，票号为：12
窗口3：卖票，票号为：11
窗口2：卖票，票号为：10
窗口1：卖票，票号为：9
窗口3：卖票，票号为：8
窗口2：卖票，票号为：7
窗口1：卖票，票号为：6
窗口3：卖票，票号为：5
窗口2：卖票，票号为：4
窗口1：卖票，票号为：3
窗口3：卖票，票号为：2
窗口2：卖票，票号为：1
窗口1：卖票，票号为：0
窗口3：卖票，票号为：-1

问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来也操作车票

如何解决：当一个线程a在操作共享数据的时候，其他线程不能参与进来,直到线程a操作完数据时，其他线程才可以开始操作数据，这种情况即使线程a出现了阻塞，也不能被改变

使用同步代码块处理实现Runnable接口的线程安全问题

class WindowThread implements Runnable{
    private int ticket = 100;
    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);
                ticket--;
            }else {
                break;
            }
            }
        }

    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        WindowThread w = new WindowThread();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

在实现Runnable接口创建多线程的方式中，可以考虑使用this充当锁，因为实现类只有一个对象

使用同步代码块处理继承Thread类的线程安全问题

class Window2 extends Thread{
    private static int ticket = 100;

    private static 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);
                ticket--;
            }else {
                break;
            }
            }
        }

    }
}
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

在继承Thread类创建多线程的方式中，如果继承类的对象有一个以上 就必须声明同步监视器为static类型。慎用this充当同步监视器，考虑使用当前类(Window2.class)充当同步监视器

运行

窗口1：卖票，票号为：100
窗口1：卖票，票号为：99
窗口1：卖票，票号为：98
窗口1：卖票，票号为：97
窗口1：卖票，票号为：96
窗口1：卖票，票号为：95
窗口1：卖票，票号为：94
窗口1：卖票，票号为：93
窗口1：卖票，票号为：92
窗口1：卖票，票号为：91
窗口1：卖票，票号为：90
窗口1：卖票，票号为：89
窗口1：卖票，票号为：88
窗口1：卖票，票号为：87
窗口1：卖票，票号为：86
窗口1：卖票，票号为：85
窗口1：卖票，票号为：84
窗口1：卖票，票号为：83
窗口1：卖票，票号为：82
窗口1：卖票，票号为：81
窗口1：卖票，票号为：80
窗口1：卖票，票号为：79
窗口1：卖票，票号为：78
窗口1：卖票，票号为：77
窗口1：卖票，票号为：76
窗口1：卖票，票号为：75
窗口1：卖票，票号为：74
窗口1：卖票，票号为：73
窗口1：卖票，票号为：72
窗口1：卖票，票号为：71
窗口1：卖票，票号为：70
窗口1：卖票，票号为：69
窗口1：卖票，票号为：68
窗口1：卖票，票号为：67
窗口1：卖票，票号为：66
窗口1：卖票，票号为：65
窗口1：卖票，票号为：64
窗口1：卖票，票号为：63
窗口1：卖票，票号为：62
窗口1：卖票，票号为：61
窗口1：卖票，票号为：60
窗口1：卖票，票号为：59
窗口1：卖票，票号为：58
窗口1：卖票，票号为：57
窗口1：卖票，票号为：56
窗口1：卖票，票号为：55
窗口1：卖票，票号为：54
窗口1：卖票，票号为：53
窗口1：卖票，票号为：52
窗口1：卖票，票号为：51
窗口1：卖票，票号为：50
窗口1：卖票，票号为：49
窗口1：卖票，票号为：48
窗口3：卖票，票号为：47
窗口3：卖票，票号为：46
窗口3：卖票，票号为：45
窗口3：卖票，票号为：44
窗口3：卖票，票号为：43
窗口3：卖票，票号为：42
窗口3：卖票，票号为：41
窗口3：卖票，票号为：40
窗口3：卖票，票号为：39
窗口3：卖票，票号为：38
窗口3：卖票，票号为：37
窗口3：卖票，票号为：36
窗口3：卖票，票号为：35
窗口3：卖票，票号为：34
窗口3：卖票，票号为：33
窗口3：卖票，票号为：32
窗口3：卖票，票号为：31
窗口3：卖票，票号为：30
窗口3：卖票，票号为：29
窗口3：卖票，票号为：28
窗口3：卖票，票号为：27
窗口2：卖票，票号为：26
窗口2：卖票，票号为：25
窗口2：卖票，票号为：24
窗口2：卖票，票号为：23
窗口2：卖票，票号为：22
窗口2：卖票，票号为：21
窗口2：卖票，票号为：20
窗口2：卖票，票号为：19
窗口2：卖票，票号为：18
窗口2：卖票，票号为：17
窗口2：卖票，票号为：16
窗口2：卖票，票号为：15
窗口2：卖票，票号为：14
窗口2：卖票，票号为：13
窗口2：卖票，票号为：12
窗口2：卖票，票号为：11
窗口2：卖票，票号为：10
窗口2：卖票，票号为：9
窗口2：卖票，票号为：8
窗口2：卖票，票号为：7
窗口2：卖票，票号为：6
窗口2：卖票，票号为：5
窗口2：卖票，票号为：4
窗口2：卖票，票号为：3
窗口2：卖票，票号为：2
窗口2：卖票，票号为：1

反方向的钟c

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
[多线程]同步代码块处理实现Runnable及继承Thread类的线程安全问题

以多窗口售票为例:创建三个窗口卖票，总票数为100张使用实现Runnable接口的方式class WindowThread implements Runnable{ private int ticket = 100; @Override public void run() { while (true){ if (ticket > 0){ try { T
复制链接

扫一扫

专栏目录