Thread class get to know a paper core usage

Brief introduction

The point, resolve Thread usage and multi-threaded use from source

public class Thread
extends Object
implements Runnable

// Runnable接口定
public interface Runnable {

    public abstract void run();
}

//Thread重写run方法
  @Override
    public void run() {
        if (target != null) {
        //private Runnable target;最终调Runable接口实现类的run方法
            target.run();
        }
    }

Construction method resolution

 /**
     *分配新的线程对象。此构造函数与Thread（null、null、gname）具有相同的效果，
     *其中gname是线程名称。自动生成的名称的格式为“Thread-”+n，其中n是整数。
    public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
o
//这里交代可以用子类继承Thread，即Thread t=new SonThread（）；并重写Thread的run方法，调用start方法开启线程



 /**
     * 分配新的线程对象。此构造函数与Thread（null、target、gname）具有相同的效果，其中
     * gname是新生成的名称。自动生成的名称的格式为“Thread-”+n，其中n是整数。
     *
     * @param  target Runable接口实例
     *       
     */
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }


//这里交代可以用Runable接口实例作为参数给Threa，Runable接口实例实现run方法，

As can be seen from the constructor is only one way to implement threads, and that is a new class Threa out, just run different sources method, a method to achieve Runable interface to run, run a rewrite method Thrad, but in any case Runable interfaces thread is to achieve top-level interfaces, in addition to the upper surface of the thread pool, timers and other tools can also create a thread, but the bottom is clearly documented new Threa () to be implemented by the thread class thread, the official java language specification is new the only way to achieve thread.

In the blog multithreaded programming knowledge point a detailed description of how to create multiple threads

Important way

 /**
     * 返回对当前正在执行的线程对象的引用。
     *
     * @return  the currently executing thread.
     */
    @FastNative
    public static native Thread currentThread();


/**
     * 返回当前线程的名称
     *
     * @return  this thread's name.
     * @see     #setName(String)
     */
    public final String getName() {
        return name;
    }
通常的用法是 Thread.currentThread().getName()


/**
     * 
     * 是线程休眠指定时间，但是不释放锁的控制权，时间到了苏醒继续试图获取CPU执行权
     *
     * @param 参数为一个毫秒值
     *
     * @throws  IllegalArgumentException
     *          如果参数为负数
     *
     * @throws  InterruptedException
     *          如果有线程中断了当前线程。引发此异常时，当前线程的中断状态将被清除。
     */
    public static void sleep(long millis) throws InterruptedException {
        Thread.sleep(millis, 0);
    }

 
/**
     * 
     *
     *通常在其他线程调用此方法。来中断线程
     *
     *如果此线程在调用对象类的wait（）、wait（long）或wait（long，int）方法
     *或该类的join（）、join（long）、join（long，int）、sleep（long）或
     *sleep（long，int）方法时被阻止，则其中断状态将被清除，并将接收到InterruptedException。
     *
     *
     * 此外将设置中断状态
     * 中断不活动的线程没有任何效果
     *
     * @throws  SecurityException
     *         自己中断自己，如果当前线程无法修改此线程
     *
     * @revised 6.0
     * @spec JSR-51
     */
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                nativeInterrupt();
                b.interrupt(this);
                return;
            }
        }
        nativeInterrupt();
    }


 /**
     * T测试线程是否被中断，不会清除中断状态
     *
     *中断返回true，否则返回false
     *
     * @see     #interrupted()
     * @revised 6.0
     */
    @FastNative
    public native boolean isInterrupted();




 /**
     *测试线程是否被中断，并清除中断状态，如果被中断返回true否则返回false，调用两次得到结果不一样
     *
     * @see #isInterrupted()
     * @revised 6.0
     */
    @FastNative
    public static native boolean interrupted();



 /**
     * 在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。
     *
     *
     * @throws  InterruptedException
     *         如果任何线程中断了当前线程。当抛出此异常时，当前线程的中断状态将被清除。
     */
    public final void join() throws InterruptedException {
        join(0);
    }



/**
     * 在A线程中调用了B线程的join()方法时，表示只有当B线程执行完指定的时间后，A线程才能继续执行。
     *
     * <p> This implementation uses a loop of {@code this.wait} calls
     * conditioned on {@code this.isAlive}. As a thread terminates the
     * {@code this.notifyAll} method is invoked. It is recommended that
     * applications not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     *
     * @param  millis
     *        等待时间
     *
     * @throws  IllegalArgumentException
     *         参数小于0
     *
     * @throws  InterruptedException
     *          如果任何线程中断了当前线程。当抛出此异常时，当前线程的中断状态将被清除。
     */
    public final void join(long millis) throws InterruptedException {
        synchronized(lock) {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
            //当参数为0直接运行当前线程
                lock.wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                //阻塞当前线程，直到时间到了
                lock.wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
        }
    }


 /**
     * 休眠当前线程.
     * 
     *这方法已经被启用，因为休眠后不释放锁，容易死锁    
     *
     */
     //过时的
    @Deprecated
    public final void suspend() {
        throw new UnsupportedOperationException();
    }


    /**
     * 过时方法，此方法仅用于与suspend()一起使用，唤醒一个线程，
     */
    @Deprecated
    public final void resume() {
        throw new UnsupportedOperationException();
    }



/**
     *
     *这个方法过时了，用来停止线程（导致线程运行一半突然停止）没办法完成一个基本单位的操作，同时释放锁，这样导致线程不安全
     */
    @Deprecated
    public final void stop() {
        stop(new ThreadDeath());
    }


/**
     * 
     * 使得当前线程放弃CPU执行权，让线程从运行状态到就绪状态，但是不释放锁资源，状态任然是可运行状态
     * 如果某一个线程是不太紧急的线程，可以在编写时调用yield()这样会让其它线程得到更多的执行机会
     */
    public static native void yield();

In summary, if you want to pause recommended thread interrupt () to inform the target thread is interrupted to perform, rather than stop, suspend and ruseme forcibly interrupted, details multithreaded core knowledge (b)

Object class and first off the thread method

/**
     *使当前线程等待，直到另外一个线程调用此对象的notify（）方法或notifyAll（）方法唤醒去继续获得cpu执行     
     *权，或者等待指定时间重新去继续获得cpu执行权，调用此方法会释放锁资源
     *
     * @param      millis   时间毫秒值
     * @throws  IllegalArgumentException      如果参数为负数
     *               
     * @throws  IllegalMonitorStateException 
     *              如果当前线程不是对象监视器的所有者。
     * @throws  InterruptedException 
     *             如果被其他线程打断报异常，而且清除中断状态
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final void wait(long millis) throws InterruptedException {
        wait(millis, 0);
    }
    

    /**
     * 引起当前线程等待，释放锁，直到另一个线程为此对象调用notify（）方法或notifyAll（）方法。线程继续设               
     * 法获得执行权
     * 
     * 此方法只能由锁的获得者的线程调用
     *
     * @throws  IllegalMonitorStateException 如果当前线程不是对象监视器的所有者。
     * @throws  InterruptedException 
     *               线程被其他线程打断抛出异常，并清除中断状态
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    @FastNative
    public final native void wait() throws InterruptedException;



/**
     * 随机唤醒等待集中某一个线程
     *
     * @throws  IllegalMonitorStateException 如果当前线程不是此对象监视器的所有者。
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    @FastNative
    public final native void notify();




/**
     * 唤醒等待集中所有线程
     *
     *
     * @throws  IllegalMonitorStateException  如果当前线程不是此对象监视器的所有者。
     *           
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#wait()
     */
    @FastNative
    public final native void notifyAll();