快速掌握并发编程 --- 基础篇

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        System.out.println("start thread");
    }
    public static void main(String[] args) {
        ThreadDemo threadDemo1=new ThreadDemo();
        ThreadDemo threadDemo2=new ThreadDemo();
        threadDemo1.start();
        threadDemo2.start();
    }
}


 1public class Thread implements Runnable {
 2 public synchronized void start() { 
 3        if (threadStatus != 0)
 4            throw new IllegalThreadStateException(); 
 5        group.add(this); 
 6        boolean started = false;
 7        try {
 8            //调用start0方法
 9            start0();
10            started = true;
11        } finally {
12            try {
13                if (!started) {
14                    group.threadStartFailed(this);
15                }
16            } catch (Throwable ignore) {
17                /* do nothing. If start0 threw a Throwable then
18                  it will be passed up the call stack */
19            }
20        }
21    }
22    //native修饰的方法，只有观看虚拟机源码才知道这里面是怎么玩的，
23    //个人认为看虚拟机源码的必要性不是很强，如果有精力的话也不妨去瞧瞧
24    private native void start0();
25}

public class User {
    //....
}
public class Zhangsan extends User implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable接口创建线程");
    }
    public static void main(String[] args) { 
        new Thread(new Zhangsan() ).start();
    }
}


@FunctionalInterface
public interface Runnable {
    public abstract void run();
}


public class CallableDemo  implements Callable<String> {
    @Override
    public String call() throws Exception {
        //业务代码...
        return "老田写的demo";
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService=Executors. newFixedThreadPool (1);
        CallableDemo callableDemo=new CallableDemo();
        Future<String> future=executorService.submit(callableDemo);
        System. out .println(future.get());
        executorService.shutdown();
    }
}


public enum State {
        NEW,
        RUNNABLE,
        BLOCKED, 
        WAITING, 
        TIMED_WAITING, 
        TERMINATED;
}


 /**
     * start方法将导致this thread开始执行。由JVM调用this thread的run方法。
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
     * <p>
     * 结果是 调用start方法的当前线程 和 执行run方法的另一个线程 同时运行。  
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     *  多次启动线程永远不合法。 特别是，线程一旦完成执行就不会重新启动。
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }
    //start方法用synchronized修饰，为同步方法
    public synchronized void start() {
        /**
         * 对于由VM创建/设置的main方法线程或“system”组线程，不会调用此方法。 
         * 未来添加到此方法的任何新功能可能也必须添加到VM中。
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         * status=0 代表是 status 是 "NEW"。
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        /* 
         * 通知组该线程即将启动，以便将其添加到线程组的列表中，并且减少线程组的未启动线程数递减。
         * Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented.
         */
        group.add(this);
        boolean started = false;
        try {
            //通知组该线程即将启动，以便将其添加到线程组的列表中，并且减少线程组的未启动线程数递减。
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
    //native方法，JVM创建并启动线程，并调用run方法
    private native void start0();
} 

public class InterruptDemo {
    private static int  i ;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            //默认情况下 isInterrupted 返回 false、通过 thread.interrupt 变成了 true
            while(!Thread. currentThread ().isInterrupted()){
                i ++;
            }
            System. out .println("Num:"+ i );
        },"interruptDemo");
        thread.start();
        TimeUnit. SECONDS .sleep(1);
        //重点
        thread.interrupt();
    }
}