Java 多线程（1）---- 初识线程

/**
 * A <i>thread</i> is a thread of execution in a program. The Java
 * Virtual Machine allows an application to have multiple threads of
 * execution running concurrently.
 * <p>
 * Every thread has a priority. Threads with higher priority are
 * executed in preference to threads with lower priority. Each thread
 * may or may not also be marked as a daemon. When code running in
 * some thread creates a new <code>Thread</code> object, the new
 * thread has its priority initially set equal to the priority of the
 * creating thread, and is a daemon thread if and only if the
 * creating thread is a daemon.
 * <p>
 * When a Java Virtual Machine starts up, there is usually a single
 * non-daemon thread (which typically calls the method named
 * <code>main</code> of some designated class). The Java Virtual
 * Machine continues to execute threads until either of the following
 * occurs:
 * <ul>
 * <li>The <code>exit</code> method of class <code>Runtime</code> has been
 *     called and the security manager has permitted the exit operation
 *     to take place.
 * <li>All threads that are not daemon threads have died, either by
 *     returning from the call to the <code>run</code> method or by
 *     throwing an exception that propagates beyond the <code>run</code>
 *     method.
 * </ul>
 * <p>
 * 
 * ......
 * 
 * Every thread has a name for identification purposes. More than
 * one thread may have the same name. If a name is not specified when
 * a thread is created, a new name is generated for it.
 * <p>
 * ......
 * /

public Thread(Runnable target) {
    // 如果我们不指定线程的名字，那么虚拟机会根据当前已经创建的线程的数量来默认指定一个线程名
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}

/**
 * The minimum priority that a thread can have.
 */
public final static int MIN_PRIORITY = 1;

/**
 * The default priority that is assigned to a thread.
 */
public final static int NORM_PRIORITY = 5;

/**
 * The maximum priority that a thread can have.
 */
public final static int MAX_PRIORITY = 10;

import java.util.Scanner;

public class ThreadTest {

    /**
     * 第一种实现线程的方法：通过自定义类继承 Thread 类并且重写 run 方法来实现线程
     */
    public static class FirstThread extends Thread {
        public FirstThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "开始执行");
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "打印: " + i);
            }
            System.out.println(Thread.currentThread().getName() + "结束执行");
        }
    }

    // 新建并执行子线程同时模拟用户输入数据
    public static void threadTest1() {
        System.out.println("主线程开始执行");
        // 新建线程
        FirstThread firstThread = new FirstThread("线程1");
        firstThread.start(); // 启动线程
        threadTest2();
        Scanner scanner = new Scanner(System.in);
        // 等待用户输入一个数字
        int x = scanner.nextInt();
        System.out.println("您输入的数字为: " + x);
        System.out.println("主线程结束执行");  
    }

    /**
     * 第二种实现线程的方法：通过创建 Runnable 对象作为参数来创建线程并执行
     */
    public static void threadTest2() {
        // 新建 Runnable 对象并重写其 run 方法并将其作为参数来新建一个线程
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行");
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "打印: " + i);
                }
                System.out.println(Thread.currentThread().getName() + "结束执行");
            }
        };
        // 传入定义的 Runnable 对象
        Thread thread = new Thread(r, "线程2");
        thread.start(); // 开启线程
    }

    public static void main(String[] args) {
        threadTest1();
    }
}

Thread.sleep(long millis) // 让调用这个方法的线程让出 CPU，休眠参数指定的毫秒数

Thread.join() // 在线程执行过程中插入另外一个线程，并且直到这个插入的线程执行完成之后再继续执行原来的线程

Object.wait() // 让调用这个方法的线程陷入等待状态，可以通过参数设置等待时间，
              // 如果不设置参数将使得线程一直等待。
              // 注意这个方法只能在 synchronized 关键字修饰的代码块中调用，
              // 这个我们会在后面的文章中细讲。

Object.notify() // 唤醒一个因调用当前对象的 wait() 方法而陷入等待状态的线程，具体哪个线程未知。
                // 这个方法也只能在 synchronized 关键字修饰的代码块中执行

Object.notifyAll() // 唤醒所有因调用当前对象的 wait() 方法而陷入等待状态的线程。
                   // 同样，这个方法也只能在 synchronized 关键字修饰的代码块中执行。

/**
 * 守护线程的测试
 */
public static void daemonThreadTest() {
    Thread daemonThread = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "打印: " + i);
                try {
                    Thread.sleep(1000); // 守护线程休眠 1 秒
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } 
            }
        }}, "守护线程");
    daemonThread.setDaemon(true); // 设置当前线程为守护线程
    daemonThread.start(); // 开启守护线程
}

public static void main(String[] args) {
    System.out.println("主线程启动");
    daemonThreadTest();
    try {
        Thread.sleep(5000); // 主线程休眠 5 秒
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println("主线程结束");
}