精华内容
下载资源
问答
  • 暂停线程本节介绍两个被废弃的用于线程暂停和恢复的方法suspend()、resume()。主要探究废弃原因,强调线程的安全性。主要有两个原因原因1:suspend()、resume()使用不当,极易造成对公共的同步对象的独占,使其他...

    暂停线程

    本节介绍两个被废弃的用于线程暂停和恢复的方法suspend()、resume()。主要探究废弃原因,强调线程的安全性。主要有两个原因

    原因1:

    suspend()、resume()使用不当,极易造成对公共的同步对象的独占,使其他线程无法访问同步对象

    例如:

    package foreverly.cn.chapter1;

    public class SynchronizedObject {

    synchronized public void printString() {

    System.out.println("printString begin");

    if (Thread.currentThread().getName().equals("a")) {

    System.out.println("a线程永远suspend了");

    Thread.currentThread().suspend();

    }

    System.out.println("end");

    }

    }

    package foreverly.cn.chapter1;

    import foreverly.cn.chapter1.SynchronizedObject;

    public class Run {

    public static void main(String[] args) {

    try {

    final SynchronizedObject object = new SynchronizedObject();

    //使用匿名类的方式创建thread1

    // Thread thread1 = new Thread() {

    // @Override

    // public void run() {

    // object.printString();

    // }

    // () ->{

    // object.printString();

    // }

    // };

    //使用lambda表达式创建thread1

    Thread thread1 =new Thread( () ->{

    object.printString();

    });

    thread1.setName("a");

    thread1.start();

    Thread.sleep(1000);

    // thread1.resume()

    Thread thread2 = new Thread() {

    @Override

    public void run() {

    System.out.println("能打印这句话,说明thread2 启动了,但进不了printString()方法,只能打印出一个printString begin。"

    + "原因是printString()方法被suspend暂停了");

    object.printString();

    //下面的语句执行不了,因为printString()是 synchronized方法,当一个线程使用时其余线程必须等待;

    //当thread1执行printString()时被暂停,但thread1任掌握着printString()方法,thread2就必须

    //等待,所以下面的语句执行不了。

    System.out.println("这里的就输出不了,因为object.printString();已经暂停了thread2");

    }

    };

    thread2.start();

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    输出:

    printString begin

    a线程永远suspend了

    能打印这句话,说明thread2 启动了,但进不了printString()方法,只能打印出一个printString begin。原因是printString()方法被suspend暂停了

    原因2:

    容易出现因为线程的暂停而导致数据不同步的情况。

    这个有点类似于stop(),

    例如:

    线程a负责更新用户名和密码,run方法时同步的(synchronized 声明),但是当线程a更新完用户名且未更新密码,此时CPU切换至线程b执行。线程b通过a.suspend()暂停了线程a,就会出现密码不同步的现象。

    比较有意思的是我们常用的println方法,它的源码是

    synchronized (this) {

    print(x);

    newLine();

    }

    也会可能产生不同步的问题。

    展开全文
  • java暂停线程

    2019-06-01 19:08:00
    暂停线程 本节介绍两个被废弃的用于线程暂停和恢复的方法suspend()、resume()。主要探究废弃原因,强调线程的安全性。主要有两个原因 原因1: suspend()、resume()使用不当,极易造成对公共的同步对象的独占,使其他...

    暂停线程

    本节介绍两个被废弃的用于线程暂停和恢复的方法suspend()、resume()。主要探究废弃原因,强调线程的安全性。主要有两个原因

    原因1:

    suspend()、resume()使用不当,极易造成对公共的同步对象的独占,使其他线程无法访问同步对象

    例如:

    package foreverly.cn.chapter1;
    
    public class SynchronizedObject {
       synchronized public void printString() {
          System.out.println("printString begin");
          if (Thread.currentThread().getName().equals("a")) {
             System.out.println("a线程永远suspend了");
             Thread.currentThread().suspend();
          }
          System.out.println("end");
          
       }
    
    }
    package foreverly.cn.chapter1;
    import foreverly.cn.chapter1.SynchronizedObject;
    public class Run {
        public static void main(String[] args) {
            try {
                final SynchronizedObject object = new SynchronizedObject();
    //      使用匿名类的方式创建thread1            
    //       Thread thread1 = new Thread() {
    //            @Override
    //            public void run() {
    //               object.printString();
    //            }
    //          () ->{
    //             object.printString();
    //          }
    //       };
    
    //      使用lambda表达式创建thread1
                Thread thread1 =new Thread( () ->{
                    object.printString();
                });
                thread1.setName("a");
                thread1.start();
                Thread.sleep(1000);
    //       thread1.resume()
    
                Thread thread2 = new Thread() {
                    @Override
                    public void run() {
    
                        System.out.println("能打印这句话,说明thread2 启动了,但进不了printString()方法,只能打印出一个printString begin。"
                                + "原因是printString()方法被suspend暂停了");
                        object.printString();
    //      下面的语句执行不了,因为printString()是 synchronized方法,当一个线程使用时其余线程必须等待;
    //      当thread1执行printString()时被暂停,但thread1任掌握着printString()方法,thread2就必须
    //      等待,所以下面的语句执行不了。
                        System.out.println("这里的就输出不了,因为object.printString();已经暂停了thread2");
    
                    }
                };
                thread2.start();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }

    输出:

    printString begin
    a线程永远suspend了
    能打印这句话,说明thread2 启动了,但进不了printString()方法,只能打印出一个printString begin。原因是printString()方法被suspend暂停了
    

    原因2:

    容易出现因为线程的暂停而导致数据不同步的情况。

    这个有点类似于stop(),

    例如:

    线程a负责更新用户名和密码,run方法时同步的(synchronized 声明),但是当线程a更新完用户名且未更新密码,此时CPU切换至线程b执行。线程b通过a.suspend()暂停了线程a,就会出现密码不同步的现象。

    比较有意思的是我们常用的println方法,它的源码是

    synchronized (this) {
        print(x);
        newLine();
    }

    也会可能产生不同步的问题。

    转载于:https://www.cnblogs.com/for-ever-ly/p/10960627.html

    展开全文
  • 目标线程的join方法暂停当前线程,直到目前线程完成(从run()方法返回),供大家参考,具体内容如下Java代码:package Threads;import java.io.IOException;/*** Created by Frank*/public class Join {public static ...

    目标线程的join方法暂停当前线程,直到目前线程完成(从run()方法返回),供大家参考,具体内容如下

    Java代码:

    package Threads;

    import java.io.IOException;

    /**

    * Created by Frank

    */

    public class Join {

    public static void main(String[] args) {

    Thread t = new Thread() {

    public void run() {

    System.out.println("Reading");

    try {

    System.in.read();

    } catch (IOException e) {

    System.err.println(e);

    }

    System.out.println("Thread finished.");

    }

    };

    System.out.println("Starting");

    t.start();

    System.out.println("Joining");

    try {

    t.join();

    } catch (InterruptedException e) {

    // 不应该发生

    System.err.println("Who dares interrupt my sleep??");

    }

    System.err.println("Main Finished");

    }

    }

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持聚米学院。

    展开全文
  • 关于java多线程如何正确暂停的理解java暂停线程使用suspend()方法,恢复线程使用resume()方法。先看看它们如何使用:1 public class MyThread extendsThread {2 private long i = 0;3 @Override4 public voidrun()...

    关于java多线程如何正确暂停的理解

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

    先看看它们如何使用:

    1 public class MyThread extendsThread {2 private long i = 0;3 @Override4 public voidrun() {5 while (true) {6 i++;7 }8 }9 public longgetI() {10 returni;11 }12 public void setI(longi) {13 this.i =i;14 }15 }

    1 public classRun {2 public static voidmain(String[] args) {3 try{4 MyThread myThread = newMyThread();5 myThread.start();6 Thread.sleep(5000);7 //A part

    8 myThread.suspend();// 暂停9 System.out.println("A1"+System.currentTimeMillis()+",i:"+myThread.getI());10 Thread.sleep(5000);11 System.out.println("A2"+System.currentTimeMillis()+",i:"+myThread.getI());12

    13 myThread.resume();// 恢复14 //B part

    15 myThread.suspend();// 暂停16 System.out.println("B1"+System.currentTimeMillis()+",i:"+myThread.getI());17 Thread.sleep(5000);18 System.out.println("B2"+System.currentTimeMillis()+",i:"+myThread.getI());19

    20 myThread.resume();// 恢复21 //C part

    22 myThread.suspend();// 暂停23 System.out.println("C1"+System.currentTimeMillis()+",i:"+myThread.getI());24 Thread.sleep(5000);25 System.out.println("C2"+System.currentTimeMillis()+",i:"+myThread.getI());26 } catch(InterruptedException e) {27 e.printStackTrace();28 }29 }30 }

    A11490340612430,i:1940218408A21490340617430,i:1940218408B11490340617430,i:1940218408B21490340622430,i:1940218408C11490340622430,i:1940218408C21490340627431,i:1940218408

    但是使用suspend和resume方法也有缺点,一点可能就是造成公共的同步对象的独占,使得其它线程无法访问公共同步对象。

    看个例子先,ab两个线程都要访问SynchObject对象的加了同步锁的printString()方法,a先进去的时候让它执行suspe方法,让它暂停并且不再恢复,看看b还能不能进入printString()方法。

    1 public classSynchObject {2 public synchronized void printString() throwsInterruptedException{3 System.out.println("begin");4 if (Thread.currentThread().getName().equals("a")) {5 System.out.println("a线程永远被suspend了!");6 Thread.currentThread().suspend();7 }8 System.out.println("end");9 }10 }

    1 public classRun {2 public static void main(String[] args) throwsInterruptedException {3 final SynchObject object = newSynchObject();4 new Thread(newRunnable() {5 @Override6 public voidrun() {7 System.out.println("a线程准备进入printString()方法");8 try{9 object.printString();10 } catch(InterruptedException e) {11 e.printStackTrace();12 }13

    14 }15 },"a").start();16

    17 Thread.sleep(5000);18

    19 new Thread(newRunnable() {20 @Override21 public voidrun() {22 System.out.println("b线程想要进入printString()方法,但是进不去了。。。");23 System.out.println("原因是printString()方法被a线程锁定,a线程执行了suspend方法,永远暂停在那儿了。。。");24 try{25 object.printString();26 } catch(InterruptedException e) {27 e.printStackTrace();28 }29

    30 }31 },"b").start();32 }33 }

    a线程准备进入printString()方法

    begin

    a线程永远被suspend了!

    b线程想要进入printString()方法,但是进不去了。。。

    原因是printString()方法被a线程锁定,a线程执行了suspend方法,永远暂停在那儿了。。。

    对于这个占用资源的问题,还有一个很好的例子,我觉得很有必要拿出来看看,这是一个“坑”,

    1 public class MyThread extendsThread {2 private long i = 0;3 @Override4 public voidrun() {5 while (true) {6 i++;7 }8 }9 }

    1 public classRun {2 public static void main(String[] args) throwsInterruptedException {3 MyThread myThread = newMyThread();4 myThread.start();5 Thread.sleep(1000);6 myThread.suspend();7 System.out.println("main end...");8 }9 }

    main end...

    这款代码看着没什么问题,但是如果我们在while循环里面打印出每次的i值,像这样

    1 public class MyThread extendsThread {2 private long i = 0;3 @Override4 public voidrun() {5 while (true) {6 i++;7 System.out.println(i);// 这是重点8 }9 }10 }

    再看看结果

    153912169.png

    打印到一定的值它就不打印了,但是eclipse的console状态还是红色的,说明线程没结束,另外main end也没有打印,这是为什么呢?只是加了一行System.out.println()最普通的代码,其实问题就出在这个方法里,可以翻开jdk源码,看看它的实现

    153912170.png

    可以看到内部是加了同步锁的,这就好理解了,main方法里线程启动,然后执行,然后睡眠1秒,然后执行suspend暂停线程,在这1秒之前while循环一直正常可以打印数字,当执行到suspend时,线程暂停,但是由于println方法内部加了同步锁,线程又一直处于暂停状态,所以它就永远僵在这儿了,后面的数字由于线程暂停了肯定不会打印了,由于它又同时占用着println方法的同步资源,所以导致main end也不会被打印。

    上面两个例子是suspend用的不好可能会独占公共资源的问题,它还有一个问题就是suspend方法与resume方法可能不同步。

    1 public classMyObject {2 private String username = "1";3 private String password = "11";4

    5 public voidsetvalue(String uname,String pwd){6 this.username =uname;7 if (Thread.currentThread().getName().equals("a")) {8 System.out.println("a线程被暂停了。。。");9 Thread.currentThread().suspend();10 }11 this.password =pwd;12 }13

    14 public voidprintstr(){15 System.out.println(username+"//"+password);16 }17 }

    1 public classRun {2 public static void main(String[] args) throwsInterruptedException {3 final MyObject myObject = newMyObject();4

    5 new Thread(newRunnable() {6 @Override7 public voidrun() {8 myObject.setvalue("a", "aa");9 }10 },"a").start();11

    12 Thread.sleep(500);13

    14 new Thread(newRunnable() {15 @Override16 public voidrun() {17 myObject.printstr();18 }19 },"b").start();20 }21 }

    153912171.png

    展开全文
  • 匿名用户1级2016-11-24 回答很简单,我给你写一个Demo:import java.awt.event.*;import javax.swing.*;public class Demo extends Thread {private JFrame frm = new JFrame("Demo");private JButton btnPause = ...
  • importjava.util.Scanner;publicclassThread2{publicstaticvoidmain(String[]args){TextThread1t1=newTextThread1("线程1");TextThread2t2=newTextThread2("线程2");i...package message;import java.uti...
  • 近日由于项目需要用到quartz组件实现调度管理功能,想要实现调度的启动和暂停以及恢复功能,但是暂停遇到问题暂停后重新启动,会连续多次调用job中的execute方法。如果当前工作的处理时间过长必然会导致问题。代码...
  • Thread类Java Thread.Sleep()暂停当前线程Thread.sleep()被用来暂停当前线程的执行,会通知线程调度器把当前线程在指定的时间周期内置为wait状态。当wait时间结束,线程状态重新变为Runnable并等待CPU的再次调度执行...
  • 休眠在Java多线程中,可以使用sleep()方法在指定毫秒数内让当前正在执行的线程休眠。下面这段代码,使得主函数的main线程休眠了2000ms,最后输出的间隔时间也是2000ms。public class MyThread extends Thread {...
  • 前言继上一篇《Java多线程之基本概念》,本章详细介绍Java多线程中线程如何进行控制。线程控制基本方法线程生命周期生命周期图JDK中用Thread.State枚举表示了线程的几种状态。要想实现多线程,必须在主线程中创建新...
  • java GUI中,如果想通过某个按钮或其他用户可交互控控制件主线程之外的线程的暂停和继续,怎么办呢?这是我想到的一个办法。这里提供一个java API文档链接:http://docs.oracle.com/javase/8/docs/api/index.html...
  • 我希望完成的工作基本上是使我的JavaScript能够在代码中的某个点“暂停”自身(例如,在函数调用的一半),并且只有在Java允许的情况下稍后才能自我恢复。为了说明我的意思,请想象以下JavaScri...
  • 今天蹭个热度, 聊聊Java里的垃圾回收.Java虚拟机自动内存管理,将原本需要由开发人员手动回收的内存, 交给垃圾回收器来自动回收.既然是自动机制, 肯定没有手动回收那样的精准高效, 而且还会带来不少与垃圾回收实现...
  • 1.java数据类型基本数据类型(原始数据类型) (3大类 8小类) 1个字节=8位 (1B=8bit) 【位是存储数据的最小单位,而字节是存储数据的基本单位】byte --> 1个字节 (-128~127)能存最大的数127short -->2个字节 (-...
  • 如何从另一个线程中暂停和恢复Java线程我正在用Java Swing编写一个应用程序。 我需要的是一个程序,我可以使用graphics界面中的button来停止“精化”线程。这里有一个简单的项目,侧重于我所需要的import java.util....
  • 你在错误的轨道上.线程池拥有线程,并通过与你的代码共享它们可能会让事情变得更糟.您应该专注于使您的任务(传递到线程可撤销/可中断),而不是直接与池拥有的线程进行交互.此外,您不知道在尝试中断线程时执行什么工作,...
  • 由于要做暂停和恢复,这里我就没有使用Android的CountDownTimer,而是用了Java的Timer。所以,这个方法在java肯定是通用。我也外加了Android独有的Service,有些计时器需要在Activiy关闭的情况下依然在计时,回到...
  • } } 运行结果: 暂停线程之 join() 方法 : join()方法是唯一一个将调用的他的线程进入阻塞状态,然后等待其他进程完成后,它在进去就绪状态,等待CPU的资源调用。 package com.bjsxt.MythreadJoin; public class ...
  • 搞懂什么是Java异常——Java学习笔记搞懂什么是Java异常——Java学习笔记异常概述Java异常指的是程序在执行过程中,出现的和正常的情况不一致的一个情况,这个时候就会最终导致JVM的非正常停止。在我们编程过程中,...
  • 我正在用Java Swing编写应用程序。我需要的是一个可以使用图形界面中的按钮停止“阐述”线程的过程。这里有一个简单的项目专注于我的需求import java.util.logging.Level;import java.util.logging.Logger;import ...
  • Java程序运行时,内部同时有多条线程,而此时需要一个线程调度机制,Java线程的调度机制是抢占式调度:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个线程执行。 创建线程的两种方式 在Java...
  • date = sDateFormat.format(new java.util.Date()); time = stimeFormat.format(new java.util.Date()); //发送 message = username + "," + deviceid + "," + date + "," + time + "," + preferences.getString(...
  • 在我们用JAVA做客户端的时候,可能会遇上这么一个需求:停止当前正在执行的一个操作。这个操作或者操作时间过长而让客户不想等待它,从而要停止它的执行。那这个操作怎么做呢?我们都知道,我们在使用事件触发来执行...
  • GC roots就是一组必须活跃的引用java使用了可达性分析的方法来判断对象是否是垃圾。基本思路就是从GC Roots对象作为起点向下搜索,如果一个对象到GC Roots没有任何的引用链时候,则说明对象不可用。2. 可以作为GC ...
  • Java虚拟机一直是比较重要的知识点,是Java高级开发必会的。本文为你总结了关于JVM的22个重点、难点,图文并茂的向你展示和JVM有关的重点知识。概念虚拟机:指以软件的方式模拟具有完整硬件系统功能、运行在一个完全...
  • packagecom.easyway.app.quartz.mgr;importjava.util.Date;importjava.util.List;importjava.util.Map;importorg.quartz.JobDataMap;importorg.quartz.JobDetail;importorg.quartz.JobKey;importorg.quartz....
  • “ 随着业务量的增加,多线程处理成为家常便饭。于是,多线程优化成了摆...Java内部锁优化当使用 Java 多线程访问共享资源的时候,会出现竞态的现象。即随着时间的变化,多线程“写”共享资源的最终结果会有所不同。...
  • 学习在事件方面的思考确实是关键。你能行的。 ????第一个规则是:永远不会停止UI线程。 UI线程负责保持您的应用程序感觉响应。你在那里做的任何工作都不应该阻止;做你需要做的,并尽快返回。绝对避免在UI线程上执行I...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,814
精华内容 2,325
关键字:

java暂停

java 订阅