Java多线程详解（四）------复习

Thread.State
 
 
 
public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,(新建)

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,（准备就绪）

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,（阻塞）

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * 

     *   
{
@link Object#wait() Object.wait} with no timeout
     *   
{@link #join() Thread.join} with no timeout
     *   
{@link LockSupport#park() LockSupport.park}
     * 
     *
     * 
A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called Object.wait()
     * on an object is waiting for another thread to call
     * Object.notify() or Object.notifyAll() on
     * that object. A thread that has called Thread.join()
     * is waiting for a specified thread to terminate.
     */
    WAITING,（不见不散）

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * 

     *   
{
@link #sleep Thread.sleep}
     *   
{@link Object#wait(long) Object.wait} with timeout
     *   
{@link #join(long) Thread.join} with timeout
     *   
{@link LockSupport#parkNanos LockSupport.parkNanos}
     *   
{@link LockSupport#parkUntil LockSupport.parkUntil}
     * 
     */
    TIMED_WAITING,（过时不候）

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;(终结)
}
 
 

 1 class X {
 2    private final ReentrantLock lock = new ReentrantLock();
 3    // ...
 4  
 5    public void m() {
 6      lock.lock();  // block until condition holds
 7      try {
 8        // ... method body
 9      } finally {
10        lock.unlock()
11      }
12    }
13  }
14  
15  
16 synchronized与Lock的区别 
17  
18 两者区别：
19 1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
20 2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
21 3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
22 4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
23 5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
24 6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

 1 package com.study.thread;
 2 
 3 public class ThreadTest {
 4     public static void main(String[] args) {
 5         for(int i=0;i){
 6             //继承Thread类，覆写run（）方法，创建多线程
 7             ThreadDemo t = new ThreadDemo();
 8             t.start();
 9         }
10 
11     }
12 }
13 class ThreadDemo extends Thread{
14     @Override
15     public void run(){
16         System.out.println("hello world");
17     }
18 }

 1 package com.study.thread;
 2 
 3 public class ThreadTest {
 4     public static void main(String[] args) {
 5         for (int i = 0; i ) {
 6             //继承Thread类，覆写run（）方法，创建多线程
 7 //            ThreadDemo t = new ThreadDemo();
 8 //            t.start();
 9             Thread t = new Thread(new RunnableDemo());
10             t.start();
11         }
12 
13     }
14 }
15 
16 class ThreadDemo extends Thread {
17     @Override
18     public void run() {
19         System.out.println("hello world");
20     }
21 }
22 
23 class RunnableDemo implements Runnable {
24 
25     @Override
26     public void run() {
27         System.out.println("hello Runnable");
28     }
29 }

 1 public class ThreadTest {
 2     public static void main(String[] args) {
 3         for (int i = 0; i ) {
 4             //继承Thread类，覆写run（）方法，创建多线程
 5 //            ThreadDemo t = new ThreadDemo();
 6 //            t.start();
 7 //            Thread t = new Thread(new RunnableDemo());
 8 //            t.start();
 9             new Thread(new Runnable() {
10                 @Override
11                 public void run() {
12                     System.out.println("hello 匿名内部类");
13                 }
14             }).start();
15         }
16 
17     }
18 }