多线程_基础知识

程序 进程 线程 纤程

• QQ.ext 程序
• 登录是三个QQ 就是三个进程

线程和纤程的不同:

• 线程在系统级 纤程在用户级
• 线程切换重 纤程切换轻
• 线程不能new 10000+ 不然CPU浪费在线程的切换上

并发（concurrency）和并行（parallellism):

• 解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。
• 解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。
• 解释三：并行是在多台处理器上同时处理多个任务。如 hadoop 分布式集群，并发是在一台处理器上“同时”处理多个任务。

多线程的创建与运行

1. 创建线程的三种方式
   a. extend Thread
   b. implements Runnable ( java8写法)
   c. 线程池(获取)
2. run与start的区别:
   a. run 可以理解为进程(run执行完,才执行main方法 串行)
   b. start 是启动线程(并行)

public class Thread_01_comment_method {

    static class  test1 extends Thread{

        @Override
        public void run(){
            for (int i = 0; i < 10; i++) {
                try{
                    Thread.sleep(1);
                    System.out.println("hahaha  extend thread");
                }catch (Exception e){

                }
            }
        }
    }


    static class test2 implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try{
                    Thread.sleep(1);
                    System.out.println("heiheihei  implement runnable");
                }catch (Exception e){

                }
            }
        }
    }

    /**
     * 创建线程的三种方式  extend Thread  implements Runnable   线程池   (java8写法)
     * run 可以理解为进程(run执行完,才执行main方法 串行)  start 是启动线程(并行)
     * @param args
     */
    public static void main(String[] args) {
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try{
                    Thread.sleep(1);
                    System.out.println("啦啦啦啦 this is java8");
                }catch (Exception e){

                }
            }
        }).start();
        new test1().start();
        new Thread(new test2()).start();
        for (int i = 0; i < 10; i++) {
            try{
                Thread.sleep(1);
                System.out.println("I love study java");
            }catch (Exception e){

            }
        }
    }


}

线程的六种状态及转换:
状态分析:

1. NEW – 线程的创建
2. RUNNABLE – ready + running
   a. ready 等待队列中的线程状态
   b. running 正在执行的状态
3. BLOCKED – 阻塞状态
   a. 没有拿到 synchronize 锁 在等待的线程
4. WAITING – 等待
5. TIMED_WAITING – 指定时间等待
6. TERMINATED – 死亡

wait 和 sleep 的区别:
1 sleep(long millis)是Thread的静态方法，用于为线程指定睡眠时间，期间并不释放同步锁，时间到达后恢复线程执行
2 wait()是Object的final方法，会把调用者线程挂起，同时释放锁，直到被notify/notifyAll等方法唤醒或者超时，之后和其它线程共同竞争CPU。
3 wait(long millis) 指定时间内,没有被唤醒,到时后直接唤醒到等待队列中

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:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * 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:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

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

yield 和 join 方法试验:
知识回顾

1. sleep 睡眠之后回到等待区
2. yield 礼貌退出执行,回到等待区重新抢cpu
3. join 等join的线程执行完才执行自己的线程

public class Thread_02_yield_join {


    /**
     * @param args
     */
    public static void main(String[] args) {

        yield();

        threadJoin();

        ABC排序();
    }


    /**
     * sleep 睡眠之后回到等待区
     */
    private static void ABC排序() {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {

            }

            System.out.println("AAAAAAAAAAAAAAA");
        }
        );

        Thread t2 = new Thread(() -> {

            try {
                t1.join();
            } catch (Exception e) {

            }
            System.out.println("BBBBBBBBBBBBBB");
        }
        );

        Thread t3 = new Thread(() -> {

            try {
                t2.join();
            } catch (Exception e) {

            }
            System.out.println("CCCCCCCCCCCCCCCC");
        }
        );


        t1.start();
        //打断
        t1.interrupt();
        t3.start();
        t2.start();

    }

    /**
     * join 等join的线程执行完才执行自己的线程
     */
    private static void threadJoin() {
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {

            }
            for (int i = 0; i < 10; i++) {
                System.out.println("AAAAAAAAAAAAAAAAAA");
            }
        });


        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                if (i == 5) {
                    try {
                        t2.join();
                    } catch (Exception e) {

                    }
                }
                System.out.println("BBBBBBBBBBBBBB");
            }
        });

        t2.start();
        t1.start();
    }

    /**
     * yield  礼貌退出执行,回到等待区重新抢cpu
     */
    private static void yield() {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                if (i == 5) {
                    Thread.yield();
                }
                System.out.println("BBBBBBBBBBBBBB");
            }
        }).start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("AAAAAAAAAAAAAAAAAA");
            }
        }).start();
    }
}