精华内容
下载资源
问答
  • } 所以现在线程在部署应用程序时运行但由于while循环被注释它没有任何实际意义. 当我的应用程序加载时,我需要在后台运行一个线程,并且不断(没有超时)检查某个队列中的对象.当然,一旦有了对象,它就“照顾它们”,然后...

    编辑:

    我现在确定问题与此有关

    ????while(true)循环保存所有其他命令,因为我已将其注释掉,并且应用程序在没有附加异常的情况下进行部署.我不确定它有多重要,但我的ServletContextListener实现如下所示:

    ?????????公共类BidPushService实现ServletContextListener {

    public void contextInitialized(ServletContextEvent sce) {

    //Some init code not relevant, omitted for clarity

    BidPushThread t= new BidPushThread();

    t.setServletContext(sce.getServletContext());

    t.run();

    }

    所以现在线程在部署应用程序时运行但由于while循环被注释它没有任何实际意义.

    当我的应用程序加载时,我需要在后台运行一个线程,并且不断(没有超时)检查某个队列中的对象.当然,一旦有了对象,它就“照顾它们”,然后继续检查队列.

    目前,我正在实现ServletContextListener接口,并在应用程序加载时调用.在其中,我做了一些维护工作并启动了一个我从java.lang.Thread继承的线程.

    这是我的问题开始的地方(或者我认为).在我的run()方法中,我有一个

    while (true) {

    //some code which doesn't put the thread to sleep ever

    }

    当我尝试将我的应用程序部署到服务器时,我得到一个java.util.concurrent.TimeOutException.

    我究竟做错了什么?

    我不能有一个始终运行的线程吗?删除应用程序后,该线程将由ServletContextListener中的相应事件停止.

    我确实需要能够毫不拖延地检查队列的东西.

    非常感谢您的帮助!

    编辑:这是堆栈跟踪

    GlassFish: deploy is failing=

    java.util.concurrent.TimeoutException

    at java.util.concurrent.FutureTask$Sync.innerGet(Unknown Source)

    at java.util.concurrent.FutureTask.get(Unknown Source)

    at com.sun.enterprise.jst.server.sunappsrv.SunAppServerBehaviour.publishDeployedDirectory(SunAppServerBehaviour.java:710)

    at com.sun.enterprise.jst.server.sunappsrv.SunAppServerBehaviour.publishModuleForGlassFishV3(SunAppServerBehaviour.java:569)

    at com.sun.enterprise.jst.server.sunappsrv.SunAppServerBehaviour.publishModule(SunAppServerBehaviour.java:266)

    at org.eclipse.wst.server.core.model.ServerBehaviourDelegate.publishModule(ServerBehaviourDelegate.java:948)

    at org.eclipse.wst.server.core.model.ServerBehaviourDelegate.publishModules(ServerBehaviourDelegate.java:1038)

    at org.eclipse.wst.server.core.model.ServerBehaviourDelegate.publish(ServerBehaviourDelegate.java:872)

    at org.eclipse.wst.server.core.model.ServerBehaviourDelegate.publish(ServerBehaviourDelegate.java:708)

    at org.eclipse.wst.server.core.internal.Server.publishImpl(Server.java:2690)

    at org.eclipse.wst.server.core.internal.Server$PublishJob.run(Server.java:272)

    at org.eclipse.core.internal.jobs.Worker.run(Worker.java:55)

    我的代码:

    public class BidPushThread extends Thread {

    private ServletContext sc=null;

    @Override

    public void run() {

    if (sc!=null){

    final Map> aucWatchers = (Map>) sc.getAttribute("aucWatchers");

    BlockingQueue aucBids = (BlockingQueue) sc.getAttribute("aucBids");

    Executor bidExecutor = Executors.newCachedThreadPool();

    final Executor watcherExecutor = Executors.newCachedThreadPool();

    while(true)

    {

    try // There are unpublished new bid events.

    {

    final Bid bid = aucBids.take();

    bidExecutor.execute(new Runnable(){

    public void run() {

    List watchers = aucWatchers.get(bid.getAuctionId());

    for(final AsyncContext aCtx : watchers)

    {

    watcherExecutor.execute(new Runnable(){

    public void run() {

    // publish a new bid event to a watcher

    try {

    aCtx.getResponse().getWriter().print("A new bid on the item was placed. The current price "+bid.getBid()+" , next bid price is "+(bid.getBid()+1));

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    };

    });

    }

    }

    });

    } catch(InterruptedException e){}

    }

    }

    }

    public void setServletContext(ServletContext sc){

    this.sc=sc;

    }

    }

    对不起格式化的混乱,但对于我的“缩进代码4个空格”的生命,对我来说不起作用

    编辑:阅读’BlockingQueue’并实现它,但我仍然得到完全相同的异常和堆栈跟踪.更改了上面的代码以反映’BlockingQueue’的使用

    展开全文
  • java让一个线程一直运行。java代码

    千次阅读 2018-10-17 09:50:29
    public class MyThread{ public static void Thread(){ new Thread() { int i = 0;... 在线程中写一个死循环 ,线程就可以一直运行,里面在加一个sleep() 方法 就能他每隔多长时间运行一次。
    public class MyThread{
    	
    	public static void Thread(){	
    		new Thread() {
    			int i = 0;
    			public void run(){
    			boolean flg = false;	
    			while(!flg){				
    				try {
    					i++;
    					System.out.println("我是"+i);
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}	
    		}
    		}.start();
    	}
    	
    	public static void main(String[] args) {
    		Thread();
    	}
    }

    下面是控制台输出的代码

     在线程中写一个死循环  ,线程就可以一直运行,里面在加一个sleep() 方法  就能让他每隔多长时间运行一次。

    展开全文
  • 比如这线程停了,马上唤醒它!一直运行,有什么方法,写死循行不通!
  • 前言Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。...一个进程一直运行,直到所有的非守护线程都结束运行...

    前言

    Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

    多线程是多任务的一种特别的形式,但多线程使用了更小的资源开销。

    这里定义和线程相关的另一个术语 - 进程:一个进程包括由操作系统分配的内存空间,包含一个或多个线程。一个线程不能独立的存在,它必须是进程的一部分。一个进程一直运行,直到所有的非守护线程都结束运行后才能结束。

    多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

    一、一个线程的生命周期

    线程是一个动态执行的过程,它也有一个从产生到死亡的过程。

    下图显示了一个线程完整的生命周期。

    b97677467c4f66d697abca87ddf34719.png

    1. 新建状态

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

    2. 就绪状态

    当线程对象调用了start()方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要等待JVM里线程调度器的调度。

    3. 运行状态: 如果就绪状态的线程获取 CPU 资源,就可以执行 run(),此时线程便处于运行状态。处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。

    4. 阻塞状态

    如果一个线程执行了sleep(睡眠)、suspend(挂起)等方法,失去所占用资源之后,该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种:

    • 等待阻塞:运行状态中的线程执行 wait() 方法,使线程进入到等待阻塞状态。
    • 同步阻塞:线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
    • 其他阻塞:通过调用线程的 sleep() 或 join() 发出了 I/O 请求时,线程就会进入到阻塞状态。当sleep() 状态超时,join() 等待线程终止或超时,或者 I/O 处理完毕,线程重新转入就绪状态。

    5. 死亡状态: 一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态。

    二、线程的优先级

    每一个 Java 线程都有一个优先级,这样有助于操作系统确定线程的调度顺序。

    Java 线程的优先级是一个整数,其取值范围是 1 (Thread.MIN_PRIORITY ) - 10 (Thread.MAX_PRIORITY )。

    默认情况下,每一个线程都会分配一个优先级 NORM_PRIORITY(5)。

    具有较高优先级的线程对程序更重要,并且应该在低优先级的线程之前分配处理器资源。但是,线程优先级不能保证线程执行的顺序,而且非常依赖于平台。

    三、创建一个线程

    Java 提供了三种创建线程的方法:

    • 通过实现 Runnable 接口;
    • 通过继承 Thread 类本身;
    • 通过 Callable 和 Future 创建线程。

    四、通过实现 Runnable 接口来创建线程

    创建一个线程,最简单的方法是创建一个实现 Runnable 接口的类。

    为了实现 Runnable,一个类只需要执行一个方法调用 run(),声明如下:

    public void run()

    你可以重写该方法,重要的是理解的 run() 可以调用其他方法,使用其他类,并声明变量,就像主线程一样。

    在创建一个实现 Runnable 接口的类之后,你可以在类中实例化一个线程对象。

    Thread 定义了几个构造方法,下面的这个是我们经常使用的:

    Thread(Runnable threadOb,String threadName);

    这里,threadOb 是一个实现 Runnable 接口的类的实例,并且 threadName 指定新线程的名字。

    新线程创建之后,你调用它的 start() 方法它才会运行。

    void start();

    下面是一个创建线程并开始让它执行的实例:

    实例

    class RunnableDemo implements Runnable {   private Thread t;   private String threadName;      RunnableDemo( String name) {      threadName = name;      System.out.println("Creating " +  threadName );   }      public void run() {      System.out.println("Running " +  threadName );      try {         for(int i = 4; i > 0; i--) {            System.out.println("Thread: " + threadName + ", " + i);            // 让线程睡眠一会            Thread.sleep(50);         }      }catch (InterruptedException e) {         System.out.println("Thread " +  threadName + " interrupted.");      }      System.out.println("Thread " +  threadName + " exiting.");   }      public void start () {      System.out.println("Starting " +  threadName );      if (t == null) {         t = new Thread (this, threadName);         t.start ();      }   }} public class TestThread {    public static void main(String args[]) {      RunnableDemo R1 = new RunnableDemo( "Thread-1");      R1.start();            RunnableDemo R2 = new RunnableDemo( "Thread-2");      R2.start();   }   }

    编译以上程序运行结果如下:

    Creating Thread-1Starting Thread-1Creating Thread-2Starting Thread-2Running Thread-1Thread: Thread-1, 4Running Thread-2Thread: Thread-2, 4Thread: Thread-1, 3Thread: Thread-2, 3Thread: Thread-1, 2Thread: Thread-2, 2Thread: Thread-1, 1Thread: Thread-2, 1Thread Thread-1 exiting.Thread Thread-2 exiting.

    五、通过继承Thread来创建线程

    创建一个线程的第二种方法是创建一个新的类,该类继承 Thread 类,然后创建一个该类的实例。

    继承类必须重写 run() 方法,该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

    该方法尽管被列为一种多线程实现方式,但是本质上也是实现了 Runnable 接口的一个实例。

    实例

    class ThreadDemo extends Thread {   private Thread t;   private String threadName;      ThreadDemo( String name) {      threadName = name;      System.out.println("Creating " +  threadName );   }      public void run() {      System.out.println("Running " +  threadName );      try {         for(int i = 4; i > 0; i--) {            System.out.println("Thread: " + threadName + ", " + i);            // 让线程睡眠一会            Thread.sleep(50);         }      }catch (InterruptedException e) {         System.out.println("Thread " +  threadName + " interrupted.");      }      System.out.println("Thread " +  threadName + " exiting.");   }      public void start () {      System.out.println("Starting " +  threadName );      if (t == null) {         t = new Thread (this, threadName);         t.start ();      }   }} public class TestThread {    public static void main(String args[]) {      ThreadDemo T1 = new ThreadDemo( "Thread-1");      T1.start();            ThreadDemo T2 = new ThreadDemo( "Thread-2");      T2.start();   }   }

    编译以上程序运行结果如下:

    Creating Thread-1Starting Thread-1Creating Thread-2Starting Thread-2Running Thread-1Thread: Thread-1, 4Running Thread-2Thread: Thread-2, 4Thread: Thread-1, 3Thread: Thread-2, 3Thread: Thread-1, 2Thread: Thread-2, 2Thread: Thread-1, 1Thread: Thread-2, 1Thread Thread-1 exiting.Thread Thread-2 exiting.

    六、Thread 方法

    下表列出了Thread类的一些重要方法:

    aac0b17067ffbcfc25ffc327692190d2.png

    测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。

    0a3d10c1acb99e43a8b1571017a531c9.png

    实例

    如下的ThreadClassDemo 程序演示了Thread类的一些方法:

    DisplayMessage.java 文件代码

    // 文件名 : DisplayMessage.java// 通过实现 Runnable 接口创建线程public class DisplayMessage implements Runnable {   private String message;      public DisplayMessage(String message) {      this.message = message;   }      public void run() {      while(true) {         System.out.println(message);      }   }}

    GuessANumber.java 文件代码

    // 文件名 : GuessANumber.java// 通过继承 Thread 类创建线程 public class GuessANumber extends Thread {   private int number;   public GuessANumber(int number) {      this.number = number;   }      public void run() {      int counter = 0;      int guess = 0;      do {         guess = (int) (Math.random() * 100 + 1);         System.out.println(this.getName() + " guesses " + guess);         counter++;      } while(guess != number);      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");   }}

    ThreadClassDemo.java 文件代码

    // 文件名 : ThreadClassDemo.javapublic class ThreadClassDemo {    public static void main(String [] args) {      Runnable hello = new DisplayMessage("Hello");      Thread thread1 = new Thread(hello);      thread1.setDaemon(true);      thread1.setName("hello");      System.out.println("Starting hello thread...");      thread1.start();            Runnable bye = new DisplayMessage("Goodbye");      Thread thread2 = new Thread(bye);      thread2.setPriority(Thread.MIN_PRIORITY);      thread2.setDaemon(true);      System.out.println("Starting goodbye thread...");      thread2.start();       System.out.println("Starting thread3...");      Thread thread3 = new GuessANumber(27);      thread3.start();      try {         thread3.join();      }catch(InterruptedException e) {         System.out.println("Thread interrupted.");      }      System.out.println("Starting thread4...");      Thread thread4 = new GuessANumber(75);            thread4.start();      System.out.println("main() is ending...");   }}

    运行结果如下,每一次运行的结果都不一样。

    Starting hello thread...Starting goodbye thread...HelloHelloHelloHelloHelloHelloGoodbyeGoodbyeGoodbyeGoodbyeGoodbye.......

    七、通过 Callable 和 Future 创建线程

    1. 创建 Callable 接口的实现类,并实现 call() 方法,该 call() 方法将作为线程执行体,并且有返回值。
    2. 创建 Callable 实现类的实例,使用 FutureTask 类来包装 Callable 对象,该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
    3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
    4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

    实例

    public class CallableThreadTest implements Callable {    public static void main(String[] args)      {          CallableThreadTest ctt = new CallableThreadTest();          FutureTask ft = new FutureTask<>(ctt);          for(int i = 0;i < 100;i++)          {              System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);              if(i==20)              {                  new Thread(ft,"有返回值的线程").start();              }          }          try          {              System.out.println("子线程的返回值:"+ft.get());          } catch (InterruptedException e)          {              e.printStackTrace();          } catch (ExecutionException e)          {              e.printStackTrace();          }        }    @Override      public Integer call() throws Exception      {          int i = 0;          for(;i<100;i++)          {              System.out.println(Thread.currentThread().getName()+" "+i);          }          return i;      }  }

    八、创建线程的三种方式的对比

    1. 采用实现 Runnable、Callable 接口的方式创建多线程时,线程类只是实现了 Runnable 接口或 Callable 接口,还可以继承其他类。
    2. 使用继承 Thread 类的方式创建多线程时,编写简单,如果需要访问当前线程,则无需使用 Thread.currentThread() 方法,直接使用 this 即可获得当前线程。

    九、线程的几个主要概念

    在多线程编程时,你需要了解以下几个概念:

    • 线程同步
    • 线程间通信
    • 线程死锁
    • 线程控制:挂起、停止和恢复

    十、多线程的使用

    有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如:程序中有两个子系统需要并发执行,这时候就需要利用多线程编程。

    通过对多线程的使用,可以编写出非常高效的程序。不过请注意,如果你创建太多的线程,程序执行的效率实际上是降低了,而不是提升了。

    请记住,上下文的切换开销也很重要,如果你创建了太多的线程,CPU 花费在上下文的切换的时间将多于执行程序的时间!

    原文转自:https://www.jianshu.com/p/53a57d7d0bfc

    展开全文
  • 线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对...

    多线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,让不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对多线程的天然支持,多线程编程不再是一道难以逾越的鸿沟。

    进程、线程、并发执行

    首先我们先来认识一下进程、线程、并发执行的概念:

    一般来说,当运行一个应用程序的时候,就启动了一个进程,当然有些会启动多个进程。启动进程的时候,操作系统会为进程分配资源,其中最主要的资源是内存空间,因为程序是在内存中运行的。

    在进程中,有些程序流程块是可以乱序执行的,并且这个代码块可以同时被多次执行。实际上,这样的代码块就是线程体。线程是进程中乱序执行的代码流程。当多个线程同时运行的时候,这样的执行模式成为并发执行。

    下面我以一个日常生活中简单的例子来说明进程和线程之间的区别和联系:

    tech_41b.jpg

    这副图是一个双向多车道的道路图,假如我们把整条道路看成是一个“进程”的话,那么图中由白色虚线分隔开来的各个车道就是进程中的各个“线程”了。

    这些线程(车道)共享了进程(道路)的公共资源(土地资源)。

    这些线程(车道)必须依赖于进程(道路),也就是说,线程不能脱离于进程而存在(就像离开了道路,车道也就没有意义了)。

    这些线程(车道)之间可以并发执行(各个车道你走你的,我走我的),也可以互相同步(某些车道在交通灯亮时禁止继续前行或转弯,必须等待其它车道的车辆通行完毕)。

    这些线程(车道)之间依靠代码逻辑(交通灯)来控制运行,一旦代码逻辑控制有误(死锁,多个线程同时竞争唯一资源),那么线程将陷入混乱,无序之中。

    这些线程(车道)之间谁先运行是未知的,只有在线程刚好被分配到CPU时间片(交通灯变化)的那一刻才能知道。

    JVM与多线程

    Java编写的程序都运行在Java虚拟机(JVM)中,在JVM的内部,程序的多任务是通过线程来实现的。

    每用java命令启动一个java应用程序,就会启动一个JVM进程。在同一个JVM进程中,有且只有一个进程,就是它自己。在这个JVM环境中,所有程序代码的运行都是以线程来运行的。JVM找到程序的入口点main(),然后运行main()方法,这样就产生了一个线程,这个线程称之为主线程。当main方法结束后,主线程运行完成。JVM进程也随即退出。

    操作系统将进程线程进行管理,轮流(没有固定的顺序)分配每个进程很短的一段时间(不一定是均分),然后在每个进程内部,程序代码自己处理该进程内部线程的时间分配,多个线程之间相互的切换去执行,这个切换时间也是非常短的。

    Java语言对多线程的支持

    Java语言对多线程的支持通过类Thread和接口Runnable来实现。这里就不多说了。这里重点强调两个地方:

    // 主线程其它代码段

    ThreadClass subThread = new ThreadClass();

    subThread.start();

    // 主线程其它代码段

    subThread.sleep(1000);

    有人认为以下的代码在调用start()方法后,肯定是先启动子线程,然后主线程继续执行。在调用sleep()方法后CPU什么都不做,就在那里等待休眠的时间结束。实际上这种理解是错误的。因为:

    start()方法的调用后并不是立即执行多线程代码,而是使得该线程变为可运行态(Runnable),什么时候运行是由操作系统决定的。

    Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源,以留出一定时间给其他线程执行的机会(也就是靠内部自己协调)。

    线程的状态切换

    前面我们提到,由于线程何时执行是未知的,只有在CPU为线程分配到时间片时,线程才能真正执行。在线程执行的过程中,由可能会因为各种各样的原因而暂停(就像前面所举的例子一样:汽车只有在交通灯变绿的时候才能够通行,而且在行驶的过程中可能会出现塞车,等待其它车辆通行或转弯的状况)。

    这样线程就有了“状态”的概念,下面这副图很好的反映了线程在不同情况下的状态变化。

    tech_42b.jpg

    新建状态(New):新创建了一个线程对象。

    就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。

    运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。

    阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。

    同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM把该线程放入锁。

    其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

    死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

    Java中线程的调度API

    Java中关于线程调度的API最主要的有下面几个:

    线程睡眠:Thread.sleep(long millis)方法

    线程等待:Object类中的wait()方法

    线程让步:Thread.yield() 方法

    线程加入:join()方法

    线程唤醒:Object类中的notify()方法

    关于这几个方法的详细应用,可以参考SUN的API。这里我重点总结一下这几个方法的区别和使用。

    sleep方法与wait方法的区别:

    sleep方法是静态方法,wait方法是非静态方法。

    sleep方法在时间到后会自己“醒来”,但wait不能,必须由其它线程通过notify(All)方法让它“醒来”。

    sleep方法通常用在不需要等待资源情况下的阻塞,像等待线程、数据库连接的情况一般用wait。

    sleep/wait与yeld方法的区别:调用sleep或wait方法后,线程即进入block状态,而调用yeld方法后,线程进入runnable状态。

    wait与join方法的区别:

    wait方法体现了线程之间的互斥关系,而join方法体现了线程之间的同步关系。

    wait方法必须由其它线程来解锁,而join方法不需要,只要被等待线程执行完毕,当前线程自动变为就绪。

    join方法的一个用途就是让子线程在完成业务逻辑执行之前,主线程一直等待直到所有子线程执行完毕。

    通过上面的介绍相信同学们对java里面的多线程已经有了基本的了解和认识。其实多线程编程并没有大家想象中的那么难,只要在实际的学习,工作当中不断的加以练习和使用,相信大家很快就能掌握其中的奥妙,从而编写出赏心悦目的java程序。

    转http://express.ruanko.com/ruanko-express_6/webpage/tech4.html

    展开全文
  • 展开全部首先,定义的锁(lock)不对,必须是同一e69da5e...其次,你如果想要呈现多线程的竞争,不可以在run方法里一个线程一直运行而不释放锁,应该使用wait()/notify();以下我稍微修改下,会形成两个线程交替执行...
  • Java线程

    2020-12-27 21:10:37
    一个进程一直运行,直到所有的非守护线程都结束运行后才能结束。 线程调度 分时调度:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。 抢占式调度:优先优先级高的线程使用
  • java线程

    2013-10-25 17:42:19
    线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对多...
  • 当A在运行期间联合了B,A线程立即中断执行,一直等到他联合的B线程执行完毕,A线程再重新排队等待CPU资源。 代码 package 合并线程join; public class JOIN { public static void main(String[] args) { Threa...
  • Java线程概述

    2016-03-16 14:27:00
    线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对...
  • 一个进程包含多个线程 进程的三个基本状态...我们首先运行一个包含输入和一个死循环的java文件,包含死循环是为了程序一直运行方便理解,这就相当于运行一个简单的程序。当轮到该程序使用CPU的时候,此时该程序...
  • Java线程介绍

    2016-04-24 11:59:53
    线程编程一直是大家比较头痛地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对多线程的...
  • Java线程理解

    千次阅读 2015-06-15 14:00:22
    线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对...
  • Java线程技术

    2015-02-05 16:31:00
    线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对...
  • Java线程之join篇

    千次阅读 2018-06-10 20:15:25
    1、Join的作用 Join方法的作用,其实就是表示一旦某个线程调用了join方法,那么就要一直运行到该线程运行结束,才会运行其他进程,我们可以有一个例子来对比一下。 1.1、不使用Joinpackage...
  • 线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对...
  • Java线程小结

    2018-02-16 21:11:24
    (保证统一的加锁解锁顺序可以避免)饥饿:由于优先级低等原因,一直抢不到锁而导致无法运行。活锁:譬如2个线程都发现对方有自己需要的锁,就主动释放锁给对方。结果双方都在谦让,以至于都在做锁的无用功。线程...
  • 而使用多线程,当一些线程发生阻塞的时候,另一些线程则仍能利用CPU,而不至于CPU一直空闲。 利用CPU的多核并行计算能力 现在的CPU基本上都是多核的。使用多线程,可以利用多核同时执行多个线程,而不至于单线程时...
  • 以前一直以为线程的"中断"就是让线程停止.如果你也这么认为,那你对多线程编程还没有入门.在java中,线程的中断(interrupt)只是改变了线程的中断状态,至于这个中断状态改变后带来的结果,那是无法确定的,有时它更是让...
  • 今天来说说多线程,看了很多遍的多线程,看完一直忘记、混淆。当然和平时的代码量有关系。好记不如烂博客。我们开始吧。 首先我们先看一张多线程的五种状态图。新建、就绪、阻塞、运行、死亡。 1.新建状态:...
  • 如何停止java线程一直是一个开发多线程程序常遇到的一个问题。也有好多人问过我,所以今天在这里总结一下希望可以更多的人知道在java中如何安全的结束一个正在运行的线程。 在Java的多线程编程中,java.lang....
  • 如何停止java线程一直是一个开发多线程程序常遇到的一个问题。也有好多人问过我,所以今天在这里总结一下希望可以更多的人知道在java中如何安全的结束一个正在运行的线程。 在Java的多线程编程中,java.lang....
  • Java线程之 interrupt(1)

    千次阅读 2011-03-16 20:16:00
    以前一直以为线程的"中断"就是让线程停止.如果你也这么认为,那你对多线程编程还没有入门.在java中,线程的中断(interrupt)只是改变了线程的中断状态,至于这个中断状态改变后带来的结果,那是无法确定的,有时它更是让...
  • JAVA线程的生命周期

    千次阅读 2019-03-05 20:10:51
    一、概述 当线程被创建以后,它不是一启动(start)就进入运行...当线程进入运行状态后,它不是一直“霸占”CPU运行,一般的操作系统是采用抢占式的方式来让线程获得CPU。所以CPU需要在多条线程之间切换,于是线程...
  • 死锁、活锁、饥饿是关于多线程是否活跃出现的运行阻塞障碍问题,如果线程出现了这三种情况,即线程不再活跃,不能再正常地执行下去了。 死锁 死锁是多线程中最差的一种情况,多个线程相互占用对方的资源的锁,而又...
  • java线程------

    2015-07-10 20:37:16
    线程编程一直是学员们比较头痛和心虚的地方,因为线程执行顺序的不可预知性和调试时候的困难,不少人在面对多线程的情况下选择了逃避,采用单线程的方式,其实只要我们对线程有了明确的认识,再加上java内置的对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390
精华内容 156
关键字:

java让线程一直运行

java 订阅