1.8暂停线程

在java中,使用suspend()方法暂停线程,使用resume()方法恢复线程的执行。

1.8.1suspend与resume的使用:

线程代码:

public class Thread1 extends Thread {
    private long i = 0L;

    public long getI() {
        return i;
    }

    public void setI(long i) {
        this.i = i;
    }

    @Override
    public void run() {
        while (true) {
            i++;
        }
    }
}

执行代码:

public class Main {
    public static void main(String[] args) {
        try {
            Thread1 thread = new Thread1();
            thread.start();
            Thread.sleep(1000);
            //A段
            thread.suspend();
            System.out.println("A = " + System.currentTimeMillis() + " I = " +thread.getI());
            //B段
            thread.resume();
            Thread.sleep(1000);
            //C段
            thread.suspend();
            System.out.println("B = " + System.currentTimeMillis() + " I = " + thread.getI());
            Thread.sleep(5000);
            System.out.println("B = " + System.currentTimeMillis() + "I = " + thread.getI());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果:

从执行的时间来看,新开启的线程确实发生了暂停(当前线程暂停与启动的时间与另外开启的线程是一致的),并且能够成功的恢复运行状态。

1.8.2suspend与resume方法的缺点——独占:

在使用suspend与resume方法时,可能会导致公共的同步对象的独占发生,使得其他线程无法访问公共同步对象。

独占代码:

public class SynchronizedObject {
    synchronized public void printString() {
        System.out.println("begin");
        if ("a".equals(Thread.currentThread().getName())) {
            System.out.println("a线程永远的暂停了,suspend");
            Thread.currentThread().suspend();
        }
        System.out.println("end");
    }
}

执行代码:

public class Main {
    public static void main(String[] args) {
        try {
            final SynchronizedObject object = new SynchronizedObject();
            Thread thread1 = new Thread() {
                @Override
                public void run() {
                    object.printString();
                }
            };
            thread1.setName("a");
            thread1.start();
            Thread.sleep(1000);
            Thread thread2 = new Thread() {
                @Override
                public void run() {
                    System.out.println("因为在Thread1中已经暂停了,后面的语句无法执行,所有只打印了begin");
                    System.out.println("因为此时Thread1已经进入了线程并且锁定了方法printString()所以什么都打不出来");
                    System.out.println("这是死锁的一种表现");
                    object.printString();
                }
            };
            thread2.setName("a");
            thread2.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

另一种陷阱式的多线程独占问题

线程代码:

public class Thread2 extends Thread {
    private long i = 0L;
    @Override
    public void run() {
        while (true) {
            i++;
            System.out.println(i);
        }
    }
}

执行代码:

public class Main {
    public static void main(String[] args) {
        try {
            Thread2 thread = new Thread2();
            thread.start();
            Thread.sleep(1000);
            thread.suspend();
            System.out.println("main end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果:

卡在数字后面,并没有打印出main end。

原因是在于println()方法,查看其源码会更加清晰:

由源码可以得知,在println内部存在同步锁,当线程在println()内部停止时,同步锁就永远不会释放,就会导致死锁。  

1.8.3suspend与resume方法的缺点——不同步:

使用这两个方法容易出现数据不同步的情况。

共享数据类:

public class MyObject {
    private String username = "1";
    private String password = "11";
    public void setValue(String u,String p) {
        this.username = u;
        if("a".equals(Thread.currentThread().getName())) {
            System.out.println("停止a线程");
            Thread.currentThread().suspend();
        }
        this.password = p;
    }
    public void printUsernamePassword() {
        System.out.println(username + "|||" + password);
    }
}

执行代码:

public class Main {
    public static void main(String[] args) {
        try {
            final MyObject object = new MyObject();
            Thread thread = new Thread() {
                @Override
                public void run() {
                    object.setValue("a","aa");
                }
            };
            thread.setName("a");
            thread.start();
            Thread.sleep(1000);
            Thread thread1 = new Thread() {
                @Override
                public void run() {
                    object.printUsernamePassword();
                }
            };
            thread1.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果:

源码地址:https://github.com/lilinzhiyu/threadLearning

本文内容是书中内容兼具自己的个人看法所成。可能在个人看法上会有诸多问题(毕竟知识量有限,导致认知也有限),如果读者觉得有问题请大胆提出,我们可以相互交流、相互学习,欢迎你们的到来,心成意足,等待您的评价。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Spark学习技巧

kafka源码系列之mysql数据增量同步到kafka

873
来自专栏蘑菇先生的技术笔记

Redis系列(三)-Redis发布订阅及客户端编程

2515
来自专栏扎心了老铁

spark-streaming集成Kafka处理实时数据

在这篇文章里,我们模拟了一个场景,实时分析订单数据,统计实时收益。 场景模拟 我试图覆盖工程上最为常用的一个场景: 1)首先,向Kafka里实时的写入订单数据,...

6005
来自专栏码匠的流水账

java降低竞争锁的一些方法

本文介绍一下提升并发可伸缩性的一些方式:减少锁的持有时间,降低锁的粒度,锁分段、避免热点域以及采用非独占的锁或非阻塞锁来代替独占锁。

481
来自专栏Kirito的技术分享

分布式限流

经典限流算法 在介绍分布式限流之前,先介绍经典限流算法。经过笔者自己的整理,核心的算法主要可以总结为以下两类四种: A类:计数器法,滑动窗口法 B类:令牌桶法,...

3659
来自专栏java思维导图

深入源码分析Java线程池的实现原理

程序的运行,其本质上,是对系统资源(CPU、内存、磁盘、网络等等)的使用。如何高效的使用这些资源是我们编程优化演进的一个方向。今天说的线程池就是一种对CPU利用...

592
来自专栏Java架构沉思录

Java中如何提升锁性能

比如100个人去银行办理业务,要填一百张表,但是只有一支笔,那么很显然,每个人用笔的时间越短,效率也就越高。看代码:

522
来自专栏Java开发者杂谈

分布式改造剧集2---DIY分布式锁

1467
来自专栏Jed的技术阶梯

Kafka 自定义分区器

(1) 如果键值为 null,并且使用了默认的分区器,那么记录将被随机地发送到主题内各个可用的分区上。分区器使用轮询(Round Robin)算法将消息均衡地分...

1052
来自专栏Spark学习技巧

kafka源码系列之mysql数据增量同步到kafka

一,架构介绍 生产中由于历史原因web后端,mysql集群,kafka集群(或者其它消息队列)会存在一下三种结构。 1,数据先入mysql集群,再入kafka ...

1.1K7

扫码关注云+社区