精华内容
下载资源
问答
  • 线程状态有 5 ,新建,就绪,运行,阻塞,死亡。关系图如下: 1. 线程 start 方法执行后,并不表示该线程运行了,而是进入就绪状态,意思是随时准备运行,但是真正何时运行,是由操作系统决定的,代码并不能...

    线程状态有 5 种,新建,就绪,运行,阻塞,死亡。关系图如下:

    1. 线程 start 方法执行后,并不表示该线程运行了,而是进入就绪状态,意思是随时准备运行,但是真正何时运行,是由操作系统决定的,代码并不能控制,

    2. 同样的,从运行状态的线程,也可能由于失去了 CPU 资源,回到就绪状态,也是由操作系统决定的。这一步中,也可以由程序主动失去 CPU 资源,只需调用 yield 方法。

    3. 线程运行完毕,或者运行了一半异常了,或者主动调用线程的 stop 方法,那么就进入死亡。死亡的线程不可逆转。

    4. 下面几个行为,会引起线程阻塞。

    • 主动调用 sleep 方法。时间到了会进入就绪状态
    • 主动调用 suspend 方法。主动调用 resume 方法,会进入就绪状态
    • 调用了阻塞式 IO 方法。调用完成后,会进入就绪状态。
    • 试图获取锁。成功的获取锁之后,会进入就绪状态。
    • 线程在等待某个通知。其它线程发出通知后,会进入就绪状态

    转载于:https://www.cnblogs.com/nongzihong/p/10512822.html

    展开全文
  • ,这5种状态如下: (1)新建(New):创建后尚未启动的线程处于这种状态 (2)运行(Runable):Runable包括了操作系统线程状态的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CP

    1.线程是什么?

        线程被称为轻量级进程,是程序执行的最小单位,它是指在程序执行过程中,能够执行代码的一个执行单位。每个程序程序都至少有一个线程,也即是程序本身。
    

    2.线程状态

        Java语言定义了5种线程状态,在任意一个时间点,一个线程只能有且只有其中一个状态。,这5种状态如下:
    

    (1)新建(New):创建后尚未启动的线程处于这种状态

    (2)运行(Runable):Runable包括了操作系统线程状态的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间。

    (3)等待(Wating):处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待,处于无限期等待的线程需要被其他线程显示地唤醒,没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态;有限期等待状态无须等待被其他线程显示地唤醒,在一定时间之后它们会由系统自动唤醒,Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。

    (4)阻塞(Blocked):线程被阻塞了,“阻塞状态”与”等待状态“的区别是:”阻塞状态“在等待着获取到一个排他锁,这个时间将在另外一个线程放弃这个锁的时候发生;而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候,线程将进入这种状态。

    (5)结束(Terminated):已终止线程的线程状态,线程已经结束执行。

    3.线程同步方法

        线程有4中同步方法,分别为wait()、sleep()、notify()和notifyAll()。
    

    wait():使线程处于一种等待状态,释放所持有的对象锁。

    sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用它时要捕获InterruptedException异常,不释放对象锁。

    notify():唤醒一个正在等待状态的线程。注意调用此方法时,并不能确切知道唤醒的是哪一个等待状态的线程,是由JVM来决定唤醒哪个线程,不是由线程优先级决定的。

    notifyAll():唤醒所有等待状态的线程,注意并不是给所有唤醒线程一个对象锁,而是让它们竞争。

    4.创建线程的方式

        在JDK1.5之前,创建线程就只有两种方式,即继承java.lang.Thread类和实现java.lang.Runnable接口;而在JDK1.5以后,增加了两个创建线程的方式,即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。
    

    4.1继承Thread类

    //继承Thread类来创建线程
    public class ThreadTest {
     
        public static void main(String[] args) {
            //设置线程名字
            Thread.currentThread().setName("main thread");
            MyThread myThread = new MyThread();
            myThread.setName("子线程:");
            //开启线程
            myThread.start();
            for(int i = 0;i<5;i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
     
    class MyThread extends Thread{
        //重写run()方法
        public void run(){
            for(int i = 0;i < 10; i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
    

    4.2实现Runnable接口

    //实现Runnable接口
    public class RunnableTest {
      
        public static void main(String[] args) {
            //设置线程名字
            Thread.currentThread().setName("main thread:");
            Thread thread = new Thread(new MyRunnable());
            thread.setName("子线程:");
            //开启线程
            thread.start();
            for(int i = 0; i <5;i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
      
    class MyRunnable implements Runnable {
      
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
    

    4.3实现Callable接口

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    //实现Callable接口
    public class CallableTest {
     
        public static void main(String[] args) {
            //执行Callable 方式,需要FutureTask 实现实现,用于接收运算结果
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
            new Thread(futureTask).start();
            //接收线程运算后的结果
            try {
                Integer sum = futureTask.get();
                System.out.println(sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
     
    class MyCallable implements Callable<Integer> {
     
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
    

    相较于实现Runnable 接口的实现,方法可以有返回值,并且抛出异常。

    4.4线程池

        线程池提供了一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁额外开销,提交了响应速度。
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    //线程池实现
    public class ThreadPoolExecutorTest {
     
        public static void main(String[] args) {
            //创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            ThreadPool threadPool = new ThreadPool();
            for(int i =0;i<5;i++){
                //为线程池分配任务
                executorService.submit(threadPool);
            }
            //关闭线程池
            executorService.shutdown();
        }
    }
     
    class ThreadPool implements Runnable {
     
        @Override
        public void run() {
            for(int i = 0 ;i<10;i++){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    
    }
    
    展开全文
  • 概述 线程是操作系统的一个概念,在Java中,它是实现并发程序的主要手段。...操作系统线程有5种状态,可以用下面的图进行描述,该图也被称为五态模型。 线程的五种状态描述如下: 初始状态。这是指线程

    概述
    线程是操作系统中的一个概念,在Java中,它是实现并发程序的主要手段。

    Java中的线程,本质上就是操作系统中的线程。

    操作系统中的线程有“生老病死”,专业说法就是生命周期,虽然不同的开发语言对于操作系统的线程做了不同的封装,但是对于线程生命周期来说,基本上是大同小异的。

    我们在学习线程的生命周期时,只要能理解生命周期中各个节点的状态转换机制就可以了。

    操作系统中的线程生命周期
    操作系统中的线程有5种状态,可以用下面的图进行描述,该图也被称为五态模型。

    线程的五种状态描述如下:
    在这里插入图片描述

    初始状态。这是指线程已经被创建,但是还不允许分配CPU执行。这个状态属于编程语言特有的,也就是说,这里所谓的被创建,仅仅是在编程语言层面上被创建,在操作系统层面上,线程是还没有被创建的。
    可运行状态。这是指线程可以分配CPU执行。在这个状态下,操作系统已经创建了线程,正在等待分配CPU。
    运行状态。这是指CPU有空闲,操作系统将其分配给一个处于可运行状态的线程,被分配到CPU的线程,就可以正常执行线程中的逻辑了。
    休眠状态。 这是指处于运行状态的线程调用了一个阻塞API或者等待某个事件。在休眠状态下,线程会释放CPU使用权,处于休眠状态的线程,是永远没有机会获得CPU使用权的。 当等待的事件出现了,线程就会从休眠状态转换到可运行状态,等待CPU重新分配。
    终止状态。这是指线程执行完成或者抛出异常。终止状态的线程不会切换到其他任何状态,这也意味着进行终止状态的线程的生命周期结束了。
    Java中的线程生命周期
    Java中的线程生命周期,基于操作系统的线程生命周期进行了定制,它包括六种状态:

    NEW(初始化状态)
    RUNNABLE(可运行/运行状态)
    BLOCKED(阻塞状态)
    WAITING(无时限等待)
    TIMED_WAITING(有时限等待)
    TERMINATED(终止状态)
    Java中的线程生命周期可以用下图来描述。
    在这里插入图片描述

    和操作系统线程生命周期相比,Java中的线程生命周期主要有以下2个改动:

    Java线程中对可运行状态和运行状态进行了合并。
    Java线程中的休眠状态被细化为:阻塞状态、无时限等待和有时限等待。
    Java线程状态转换
    Java线程状态中的阻塞、无时限等待和有时限等待可以理解为线程导致休眠状态的三种原因,我们来看一下这些状态之间是怎么转换的。

    运行状态和阻塞状态之间的转换
    在Java中,只有一种情况会出现这种状态转换:线程等待synchronized隐式锁。synchronized修饰的方法、代码块同一时刻只允许一个线程执行,其他线程只能等待,在这种情况下,等待的线程会从运行状态转换到阻塞状态,而当等待的线程获得synchronized锁后,状态会从阻塞状态转换为运行状态。

    线程调用阻塞式API时,会切换到阻塞状态吗?

    在操作系统层面,线程是会切换到休眠状态的,但是在JVM层面,Java线程的状态不会切换,也就说Java线程依然是运行状态。JVM不关心操作系统调度相关的状态。在JVM看来,等待CPU使用权和等待I/O没有区别,都是在等待某个资源,所以都属于可运行/运行状态。

    我们平时说的Java调用阻塞式API时,线程会被阻塞,我们指的是操作系统线程状态,而不是Java线程状态,这一点需要分清楚。

    运行状态和无时限等待状态的切换
    以下三种情况会触发运行状态和无时限等待状态的切换。

    获得synchronized锁的线程,调用了无参数的Object.wait()方法。
    调用无参数的Thread.join()方法。
    调用LockSupport.park()方法。
    运行状态和有时限等待状态的切换
    有时限等待和无时限等待的主要区别,在于触发条件中添加了超时参数。

    以下五种情况会触发运行状态和有时限等待状态的切换。

    调用带超时参数的Thread.sleep(long millis)方法。
    获得synchronized锁的线程,调用带超时参数的Object.wait(long timeout)方法。
    调用带超时参数的Thread.join(long millis)方法。
    调用带超时参数的LocakSupport.parkNanos(Object blocker, long deadline)方法。
    调用带超时参数的LockSupport.parkUntil(long deadlinie)方法。
    初始化状态和运行状态的切换
    Java刚创建出来的Thread对象就是初始化状态,有两种可以创建线程的方法:

    继承Thread类
    实现Runnable接口
    初始化状态的线程,并不会被操作系统调度,因此不会被执行。在调用线程对象的start()方法后,线程就会从初始化状态切换到运行状态。

    运行状态和终止状态的切换
    线程在以下两种情况时会自动切换到终止状态:

    正常执行完run()方法
    run()方法中抛出异常
    手动终止线程
    我们有2种方法终止线程:

    调用stop()方法
    调用interrupt()方法
    我们不推荐使用stop()方法,在JDK中,它已经被标记为Deprecated。我们推荐使用interrupt()方法来终止线程。

    stop()方法和interrupt()方法的区别:

    stop()方法会直接杀死线程,不给线程喘息的机会,如果此时线程持有锁,那么这个锁不会被释放,其他线程也没有办法获取这个锁。
    interrupt()方法只是通知该线程,线程有机会执行一些后续操作,同时也可以无视这个通知。
    被调用了interrupt()方法的线程,有以下2种方式接收通知:

    异常,处于有时限等待或者无时限等待状态的线程, 在被调用interrupt()方法后,线程会返回运行状态,但同时会抛出InterruptedException。
    主动监测,线程可以调用isInterrupted()方法,来判断自己是不是被中断了。
    使用jstack查看多线程状态
    在查看了Java线程生命周期中的状态以及状态之间的切换后,我们来使用jstack来查看一下真实运行的线程的状态。

    我们以一个死锁的程序为例,来说明如何使用jstack。

    我们在解释互斥锁和死锁的时候,写了一些死锁示例,代码如下。

    public class BankTransferDemo {
    	
    	public void transfer(BankAccount sourceAccount, BankAccount targetAccount, double amount) {
    		synchronized(sourceAccount) {
    			synchronized(targetAccount) {
    				if (sourceAccount.getBalance() > amount) {
    					System.out.println("Start transfer.");
    					System.out.println(String.format("Before transfer, source balance:%s, target balance:%s", sourceAccount.getBalance(), targetAccount.getBalance()));
    					sourceAccount.setBalance(sourceAccount.getBalance() - amount);
    					targetAccount.setBalance(targetAccount.getBalance() + amount);
    					System.out.println(String.format("After transfer, source balance:%s, target balance:%s", sourceAccount.getBalance(), targetAccount.getBalance()));
    				}
    			}
    		}
    	}
    }
    	public static void main(String[] args) throws InterruptedException {
    		BankAccount sourceAccount = new BankAccount();
    		sourceAccount.setId(1);
    		sourceAccount.setBalance(50000);
    		
    		BankAccount targetAccount = new BankAccount();
    		targetAccount.setId(2);
    		targetAccount.setBalance(20000);
    		
    		BankTransferDemo obj = new BankTransferDemo();
    		
    		Thread t1 = new Thread(() ->{
    			for (int i = 0; i < 10000; i++) {
    				obj.transfer(sourceAccount, targetAccount, 1);
    			}
    		});
    		
    		Thread t2 = new Thread(() ->{
    			for (int i = 0; i < 10000; i++) {
    				obj.transfer(targetAccount, sourceAccount, 1);
    			}
    		});
    		
    		t1.start();
    		t2.start();
    		
    		t1.join();
    		t2.join();
    		
    		System.out.println("Finished.");
    	}
    

    上述代码在运行过程中,因为资源争抢的原因,最后会进入死锁状态,下面我们来看一下如何使用jstack来获取具体信息。

    (base) ➜ ~ jstack -l 63044
    请注意上述的63044是运行的pid,运行程序多次产生的pid是不一样的。

    jstack的返回结果如下。

    2021-01-15 19:56:28
    Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.251-b08 mixed mode):
    
    "RMI TCP Accept-0" #14 daemon prio=9 os_prio=31 tid=0x00007fb1d80b6000 nid=0x5803 runnable [0x00007000059d8000]
       java.lang.Thread.State: RUNNABLE
    	at java.net.PlainSocketImpl.socketAccept(Native Method)
    	at java.net.AbstractPlainSocketImpl.accept(AbstractPlainSocketImpl.java:409)
    	at java.net.ServerSocket.implAccept(ServerSocket.java:545)
    	at java.net.ServerSocket.accept(ServerSocket.java:513)
    	at sun.management.jmxremote.LocalRMIServerSocketFactory$1.accept(LocalRMIServerSocketFactory.java:52)
    	at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.executeAcceptLoop(TCPTransport.java:405)
    	at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.run(TCPTransport.java:377)
    	at java.lang.Thread.run(Thread.java:748)
    
       Locked ownable synchronizers:
    	- None
    
    "Attach Listener" #12 daemon prio=9 os_prio=31 tid=0x00007fb1db03d800 nid=0x3617 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "Thread-1" #11 prio=5 os_prio=31 tid=0x00007fb1db04e800 nid=0xa603 waiting for monitor entry [0x00007000057d2000]
       java.lang.Thread.State: BLOCKED (on object monitor)
    	at com.concurrency.demo.BankTransferDemo.transfer(BankTransferDemo.java:8)
    	- waiting to lock <0x000000076ab76ef0> (a com.concurrency.demo.BankAccount)
    	- locked <0x000000076ab76f10> (a com.concurrency.demo.BankAccount)
    	at com.concurrency.demo.BankTransferDemo.lambda$1(BankTransferDemo.java:38)
    	at com.concurrency.demo.BankTransferDemo$$Lambda$2/1044036744.run(Unknown Source)
    	at java.lang.Thread.run(Thread.java:748)
    
       Locked ownable synchronizers:
    	- None
    
    "Thread-0" #10 prio=5 os_prio=31 tid=0x00007fb1d896e000 nid=0xa703 waiting for monitor entry [0x00007000056cf000]
       java.lang.Thread.State: BLOCKED (on object monitor)
    	at com.concurrency.demo.BankTransferDemo.transfer(BankTransferDemo.java:8)
    	- waiting to lock <0x000000076ab76f10> (a com.concurrency.demo.BankAccount)
    	- locked <0x000000076ab76ef0> (a com.concurrency.demo.BankAccount)
    	at com.concurrency.demo.BankTransferDemo.lambda$0(BankTransferDemo.java:32)
    	at com.concurrency.demo.BankTransferDemo$$Lambda$1/135721597.run(Unknown Source)
    	at java.lang.Thread.run(Thread.java:748)
    
       Locked ownable synchronizers:
    	- None
    
    "Service Thread" #9 daemon prio=9 os_prio=31 tid=0x00007fb1de809000 nid=0x5503 runnable [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "C1 CompilerThread3" #8 daemon prio=9 os_prio=31 tid=0x00007fb1df80a800 nid=0x3b03 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "C2 CompilerThread2" #7 daemon prio=9 os_prio=31 tid=0x00007fb1df80a000 nid=0x3a03 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "C2 CompilerThread1" #6 daemon prio=9 os_prio=31 tid=0x00007fb1df809000 nid=0x3e03 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "C2 CompilerThread0" #5 daemon prio=9 os_prio=31 tid=0x00007fb1df008800 nid=0x3803 waiting on condition [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "Signal Dispatcher" #4 daemon prio=9 os_prio=31 tid=0x00007fb1de808800 nid=0x4103 runnable [0x0000000000000000]
       java.lang.Thread.State: RUNNABLE
    
       Locked ownable synchronizers:
    	- None
    
    "Finalizer" #3 daemon prio=8 os_prio=31 tid=0x00007fb1d8810800 nid=0x3203 in Object.wait() [0x0000700004db1000]
       java.lang.Thread.State: WAITING (on object monitor)
    	at java.lang.Object.wait(Native Method)
    	- waiting on <0x000000076ab08ee0> (a java.lang.ref.ReferenceQueue$Lock)
    	at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)
    	- locked <0x000000076ab08ee0> (a java.lang.ref.ReferenceQueue$Lock)
    	at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165)
    	at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:216)
    
       Locked ownable synchronizers:
    	- None
    
    "Reference Handler" #2 daemon prio=10 os_prio=31 tid=0x00007fb1d900b000 nid=0x3103 in Object.wait() [0x0000700004cae000]
       java.lang.Thread.State: WAITING (on object monitor)
    	at java.lang.Object.wait(Native Method)
    	- waiting on <0x000000076ab06c00> (a java.lang.ref.Reference$Lock)
    	at java.lang.Object.wait(Object.java:502)
    	at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
    	- locked <0x000000076ab06c00> (a java.lang.ref.Reference$Lock)
    	at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)
    
       Locked ownable synchronizers:
    	- None
    
    "main" #1 prio=5 os_prio=31 tid=0x00007fb1db809000 nid=0x1003 in Object.wait() [0x000070000408a000]
       java.lang.Thread.State: WAITING (on object monitor)
    	at java.lang.Object.wait(Native Method)
    	- waiting on <0x000000076ab770c0> (a java.lang.Thread)
    	at java.lang.Thread.join(Thread.java:1252)
    	- locked <0x000000076ab770c0> (a java.lang.Thread)
    	at java.lang.Thread.join(Thread.java:1326)
    	at com.concurrency.demo.BankTransferDemo.main(BankTransferDemo.java:45)
    
       Locked ownable synchronizers:
    	- None
    
    "VM Thread" os_prio=31 tid=0x00007fb1db821000 nid=0x4c03 runnable
    
    "GC task thread#0 (ParallelGC)" os_prio=31 tid=0x00007fb1db809800 nid=0x1f07 runnable
    
    "GC task thread#1 (ParallelGC)" os_prio=31 tid=0x00007fb1d8008800 nid=0x1b03 runnable
    
    "GC task thread#2 (ParallelGC)" os_prio=31 tid=0x00007fb1db009000 nid=0x1d03 runnable
    
    "GC task thread#3 (ParallelGC)" os_prio=31 tid=0x00007fb1db009800 nid=0x2a03 runnable
    
    "GC task thread#4 (ParallelGC)" os_prio=31 tid=0x00007fb1db00a000 nid=0x2c03 runnable
    
    "GC task thread#5 (ParallelGC)" os_prio=31 tid=0x00007fb1db00a800 nid=0x2d03 runnable
    
    "GC task thread#6 (ParallelGC)" os_prio=31 tid=0x00007fb1db80a000 nid=0x5203 runnable
    
    "GC task thread#7 (ParallelGC)" os_prio=31 tid=0x00007fb1db00b800 nid=0x5003 runnable
    
    "GC task thread#8 (ParallelGC)" os_prio=31 tid=0x00007fb1db00c000 nid=0x4f03 runnable
    
    "GC task thread#9 (ParallelGC)" os_prio=31 tid=0x00007fb1d900a800 nid=0x4d03 runnable
    
    "VM Periodic Task Thread" os_prio=31 tid=0x00007fb1d8028800 nid=0xa803 waiting on condition
    
    JNI global references: 333
    
    
    Found one Java-level deadlock:
    =============================
    "Thread-1":
      waiting to lock monitor 0x00007fb1db8270a8 (object 0x000000076ab76ef0, a com.concurrency.demo.BankAccount),
      which is held by "Thread-0"
    "Thread-0":
      waiting to lock monitor 0x00007fb1db827158 (object 0x000000076ab76f10, a com.concurrency.demo.BankAccount),
      which is held by "Thread-1"
    
    Java stack information for the threads listed above:
    ===================================================
    "Thread-1":
    	at com.concurrency.demo.BankTransferDemo.transfer(BankTransferDemo.java:8)
    	- waiting to lock <0x000000076ab76ef0> (a com.concurrency.demo.BankAccount)
    	- locked <0x000000076ab76f10> (a com.concurrency.demo.BankAccount)
    	at com.concurrency.demo.BankTransferDemo.lambda$1(BankTransferDemo.java:38)
    	at com.concurrency.demo.BankTransferDemo$$Lambda$2/1044036744.run(Unknown Source)
    	at java.lang.Thread.run(Thread.java:748)
    "Thread-0":
    	at com.concurrency.demo.BankTransferDemo.transfer(BankTransferDemo.java:8)
    	- waiting to lock <0x000000076ab76f10> (a com.concurrency.demo.BankAccount)
    	- locked <0x000000076ab76ef0> (a com.concurrency.demo.BankAccount)
    	at com.concurrency.demo.BankTransferDemo.lambda$0(BankTransferDemo.java:32)
    	at com.concurrency.demo.BankTransferDemo$$Lambda$1/135721597.run(Unknown Source)
    	at java.lang.Thread.run(Thread.java:748)
    
    Found 1 deadlock.
    我们从中可以看到线程的状态有RUNNABLE,WAITING,BLOCKED,例如:
    
    "Thread-0" #10 prio=5 os_prio=31 tid=0x00007fb1d896e000 nid=0xa703 waiting for monitor entry [0x00007000056cf000]
       java.lang.Thread.State: BLOCKED (on object monitor)
    	at com.concurrency.demo.BankTransferDemo.transfer(BankTransferDemo.java:8)
    	- waiting to lock <0x000000076ab76f10> (a com.concurrency.demo.BankAccount)
    	- locked <0x000000076ab76ef0> (a com.concurrency.demo.BankAccount)
    	at com.concurrency.demo.BankTransferDemo.lambda$0(BankTransferDemo.java:32)
    	at com.concurrency.demo.BankTransferDemo$$Lambda$1/135721597.run(Unknown Source)
    	at java.lang.Thread.run(Thread.java:748)
    
       Locked ownable synchronizers:
    	- None
    下面是死锁的相关信息:
    
    Found one Java-level deadlock:
    =============================
    "Thread-1":
      waiting to lock monitor 0x00007fb1db8270a8 (object 0x000000076ab76ef0, a com.concurrency.demo.BankAccount),
      which is held by "Thread-0"
    "Thread-0":
      waiting to lock monitor 0x00007fb1db827158 (object 0x000000076ab76f10, a com.concurrency.demo.BankAccount),
      which is held by "Thread-1"
    

    从上面的描述中,我们可以清楚的看到2个线程在java基础互相等待对方持有的锁对象。

    jstack是一个非常实用的工具,我会在后面找机会详细的说明如何使用它和其他相关工具。

    作者:李潘
        
    出处:http://wing011203.cnblogs.com/

    展开全文
  • 创建多线程的4方式

    2018-10-18 17:19:00
    1.线程是什么? 线程被称为轻量级进程,是程序执行的最小单位,它是指在程序执行过程,能够执行代码的一个执行...,这5种状态如下: (1)新建(New):创建后尚未启动的线程处于这种状态 (2)运行(Runab...

    1.线程是什么?

            线程被称为轻量级进程,是程序执行的最小单位,它是指在程序执行过程中,能够执行代码的一个执行单位。每个程序程序都至少有一个线程,也即是程序本身

    2.线程状态

            Java语言定义了5种线程状态,在任意一个时间点,一个线程只能有且只有其中一个状态。,这5种状态如下:

    (1)新建(New):创建后尚未启动的线程处于这种状态

    (2)运行(Runable):Runable包括了操作系统线程状态的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间。

    (3)等待(Wating):处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待,处于无限期等待的线程需要被其他线程显示地唤醒,没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态;有限期等待状态无须等待被其他线程显示地唤醒,在一定时间之后它们会由系统自动唤醒,Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。

    (4)阻塞(Blocked):线程被阻塞了,“阻塞状态”与”等待状态“的区别是:”阻塞状态“在等待着获取到一个排他锁,这个时间将在另外一个线程放弃这个锁的时候发生;而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候,线程将进入这种状态。

    (5)结束(Terminated):已终止线程的线程状态,线程已经结束执行。

    下图是5种状态转换图:

     

                    

    3.线程同步方法

            线程有4中同步方法,分别为wait()、sleep()、notify()和notifyAll()。

    wait():使线程处于一种等待状态,释放所持有的对象锁。

    sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用它时要捕获InterruptedException异常,不释放对象锁。

    notify():唤醒一个正在等待状态的线程。注意调用此方法时,并不能确切知道唤醒的是哪一个等待状态的线程,是由JVM来决定唤醒哪个线程,不是由线程优先级决定的。

    notifyAll():唤醒所有等待状态的线程,注意并不是给所有唤醒线程一个对象锁,而是让它们竞争。

    4.创建线程的方式

            在JDK1.5之前,创建线程就只有两种方式,即继承java.lang.Thread类和实现java.lang.Runnable接口;而在JDK1.5以后,增加了两个创建线程的方式,即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。

    4.1继承Thread类

     

    //继承Thread类来创建线程
    public class ThreadTest {
     
        public static void main(String[] args) {
            //设置线程名字
            Thread.currentThread().setName("main thread");
            MyThread myThread = new MyThread();
            myThread.setName("子线程:");
            //开启线程
            myThread.start();
            for(int i = 0;i<5;i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
     
    class MyThread extends Thread{
        //重写run()方法
        public void run(){
            for(int i = 0;i < 10; i++){
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }

     

    4.2实现Runnable接口

    //实现Runnable接口
    public class RunnableTest {
     
    	public static void main(String[] args) {
    		//设置线程名字
    		Thread.currentThread().setName("main thread:");
    		Thread thread = new Thread(new MyRunnable());
    		thread.setName("子线程:");
    		//开启线程
    		thread.start();
    		for(int i = 0; i <5;i++){
    			System.out.println(Thread.currentThread().getName() + i);
    		}
    	}
    }
     
    class MyRunnable implements Runnable {
     
    	@Override
    	public void run() {
    		for (int i = 0; i < 10; i++) {
    			System.out.println(Thread.currentThread().getName() + i);
    		}
    	}
    }
    

    4.3实现Callable接口

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    //实现Callable接口
    public class CallableTest {
     
        public static void main(String[] args) {
            //执行Callable 方式,需要FutureTask 实现实现,用于接收运算结果
            FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
            new Thread(futureTask).start();
            //接收线程运算后的结果
            try {
                Integer sum = futureTask.get();
                System.out.println(sum);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
     
    class MyCallable implements Callable<Integer> {
     
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
            

     相较于实现Runnable 接口的实现,方法可以有返回值,并且抛出异常。

    4.4线程池

            线程池提供了一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁额外开销,提交了响应速度。

     

    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    //线程池实现
    public class ThreadPoolExecutorTest {
     
        public static void main(String[] args) {
            //创建线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            ThreadPool threadPool = new ThreadPool();
            for(int i =0;i<5;i++){
                //为线程池分配任务
                executorService.submit(threadPool);
            }
            //关闭线程池
            executorService.shutdown();
        }
    }
     
    class ThreadPool implements Runnable {
     
        @Override
        public void run() {
            for(int i = 0 ;i<10;i++){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    
    }

     

     

    转载于:https://www.cnblogs.com/zhou-test/p/9811771.html

    展开全文
  • 线程死锁和堵塞

    2020-06-01 19:44:39
    在看并发编程的第一章的时候举出了一个死锁了的例子,感觉特别棒,于是就联想到了阻塞,我们知道在JAVA环境线程Thread有如下五个状态:(当然有人要说是七个状态,这个以后有机会再说) 1,新建状态 2,就绪...
  • Java范例开发大全(全书源程序

    热门讨论 2013-04-05 11:50:26
    13.1 多线程的五基本状态 405 实例222 启动线程 405 实例223 参赛者的比赛生活(线程休眠唤醒) 407 实例224 资源搜索并下载(线程等待和通报) 410 实例225 模拟淘宝购物买卖双方交易问题 412 实例226 携子...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码...
  • 50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本概念...
  • Stateful Session Bean 与 Stateless Session Bean ,这两的 Session Bean都可以将系统逻辑放在 method之执行,不同的是 Stateful Session Bean 可以记录呼叫者的状态,因此通常来说,一个使用者会一个相对应...
  • 前言 线程:程序流执行的最小单元。...Java语言定义了5中线程状态,在任意一个时间点,一个线程只能且只有其中的一种状态5中状态如下。 新建(New):创建后尚未启动的线程处于这种状态。 运行(Runn...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java...
  • java面试题

    2018-01-01 15:35:15
    51.2. Java中线程有种状态 23 51.3. 多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 24 51.4. 线程同步的方法。 24 51.5. java中有几种方法可以实现一个线程?用什么关键字修饰同步方法? stop()和...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
     Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java...
  • java 面试题 总结

    2009-09-16 08:45:34
    Stateful Session Bean 与 Stateless Session Bean ,这两的 Session Bean都可以将系统逻辑放在 method之执行,不同的是 Stateful Session Bean 可以记录呼叫者的状态,因此通常来说,一个使用者会一个相对应...
  • java面试宝典2012

    2012-12-16 20:43:41
    50、多线程有实现方法?同步有几实现方法? 36 51、启动一个线程是用run()还是start()? . 37 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 37 53、线程的基本概念...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码...
  • JAVA面试宝典2010

    2011-12-20 16:13:24
    50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本概念...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本概念...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本概念...
  • Java 3DMenu 界面源码 5个目标文件 内容索引:Java源码,窗体界面,3DMenu Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本...
  • Java面试宝典2012新版

    2012-06-26 19:20:00
    50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本概念...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    50、多线程有实现方法?同步有几实现方法? 51、启动一个线程是用run()还是start()? . 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 53、线程的基本概念、线程...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    50、多线程有实现方法?同步有几实现方法? 33 51、启动一个线程是用run()还是start()? . 33 52、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? 33 53、线程的基本概念...
  • Thinking.In.Java

    2012-03-21 22:35:53
    经过不断的试验和修订(或称“反复”,这是在Java程序设计非常有用的一项技术),最后成功地在一门课程集成了从我的教学经验总结出来的所有东西――我在很长一段时间里都在使用。其中由一系列离散的、易于消化...
  • Java 3DMenu 界面源码 5个目标文件 内容索引:Java源码,窗体界面,3DMenu Java 3DMenu 界面源码,人说用到游戏不错,其实平时我信编写Java应用程序时候也能用到吧,不一定非要局限于游戏吧,RES、SRC资源都,都...

空空如也

空空如也

1 2 3 4 5
收藏数 90
精华内容 36
关键字:

java程序中线程有如下5种状态

java 订阅