JAVA------多线程之开始

什么是线程--What 

线程是程序中不同的执行路径

并发：并非是同一时间执行多个线程，而是在一段时间内，cpu交替执行多个线程指令。

并行：在同一时间内，多个任务同时执行

如何启动线程--How

1. 继承Thread类
2. 实现Runnable接口（有返回值时，实现Callable接口）
3. jdk8后使用表达式

调用线程的start()方法后，main线程继续执行。

package thread;

/**
 * 启动现成的几种方式
 *继承Thread
 * Runnable
 * Callable
 * 线程池 Excutors
 *
 */
public class T02_HowToCreateThread {
    static class  MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("MyThread");
        }
    }

    static class MyRun implements Runnable{
        @Override
        public void run() {
            System.out.println("MyRun");
        }
    }

    public static void main(String[] args) {
        MyThread t=new MyThread();
        t.start();

        new Thread(new MyRun()).start();

        new Thread(()->{
            System.out.println("lamuda表达式");
        }).start();

    }
}

   线程状态及控制方法

    线程状态及转换

• 新建：创建Thread对象。
• 可运行：资源准备就绪，在就绪队列中等待调度程序调用，获取cpu执行权。
• 运行：线程获取cpu执行权，真正执行指令。
• 阻塞：遇见阻塞事件，停止执行，直到停止阻塞再进入就绪队列。
• 结束：线程run()方法执行完毕，或者产生异常，此时线程结束。

  

       通过继承Thread类，或者实现Runnable接口，重写run()方法，new出新的Thread对象，此时线程处于创建（NEW）状态， 调用线程start()方法时，线程进入可运行状态（RUNNABLE），此时所有资源已准备就绪，等待调度程序调度执行。当调度程序调度到该线程时，线程进入运行状态（RUNNING）。当时间片耗尽时，线程被挂起，重新进入就绪队列，等待下一次调度；当调用yield()方法，线程退出cpu执行权，重新进入就绪队列。当线程遇见阻塞事件时，线程进入阻塞（BLOCKING）状态，直到解除阻塞状态，重新进入就绪队列。

        阻塞事件：

•    Thread.sleep()：线程进入阻塞，当睡眠时间结束，线程自动解除阻塞状态。
•    Thread.join()：线程t1中调用t2.join()方法，t1线程阻塞，等待t2线程执行完毕，t1线程继续执行；
•    等待进入同步代码块：等待锁资源分配，获取锁时，解除阻塞；

   

线程控制方法sleep()、yield()、join()

• sleep(500)：线程睡眠500毫秒
• yield()：当前线程退出cpu，返回就绪队列
• join()：当前线程将另一线程调度入cpu执行，当前线程进入阻塞状态

代码示例

package thread;

import java.util.concurrent.TimeUnit;

/**
 * sleep:线程睡眠
 * yield:线程退出，让出cpu，回到等待队列
 * join:执行时调用其他线程
 */
public class T03_Sleep_Yield_Join {
    public static void main(String[] args) {
        testJoin();
    }
    static void testSleep() {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);//睡500毫秒，让给别的线程运行
                    // TimeUnit.MICROSECONDS.sleep(500);等价
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    static void testYield() {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("B" + i);
                if (i % 10 == 0)
                    Thread.yield();
            }
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("C" + i);
                if (i % 10 == 0)
                    Thread.yield();
            }
        }).start();
    }


    static void testJoin(){
        Thread t1=new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);//睡500毫秒，让给别的线程运行
                    // TimeUnit.MICROSECONDS.sleep(500);等价
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2=new Thread(()->{
            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t2.start();
    }
}