传统的线程

package com.thread_test;

/**
 * Created by zhen on 2017-05-25.
 */
public class TraditionalThreadTest {

    public static void main(String[] args){
        /**
         * java中使用Thread类来创建线程
         * Thread的start()方法来启动线程
         */
        Thread thread = new Thread();
        thread.start();

        /**
         *  线程默认做什么事呢？线程的执行内容为run方法的内容。
         * @Override
            public void run() {
            if (target != null) {
            target.run();
            }
        }
         */
        //上面那样的直接new Thread对象然后执行，target为null，很明显线程不会执行任何代码，就很快结束了，无法达到想要的效果，我们需要重写Thread的Run方法
        //重写run方法的好方式就是new 一个Thread对象的子类，覆盖Thread的run方法。
        Thread  thread1 = new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //Thread的currentThread()得到当前线程的线程对象
                    System.out.println(Thread.currentThread().getName());
                }
            }
        };
        thread1.start();

        /**
         * 走自己的线程内容除了重写run方法之外还能怎么办呢？
         * 我们看到Thread类的默认run方法
         * @Override
            public void run() {
            if (target != null) {
            target.run();
            }
         * 我们给target对象赋值的话就ok了
         * 发现赋值是在init方法里面进行的：
         *  private void init(ThreadGroup g, Runnable target, String name,
            long stackSize, AccessControlContext acc) {
                ...
                this.target = target;
                ...
            }
         * 可惜init是private方法，继续找
         *  public Thread(Runnable target) {
                init(null, target, "Thread-" + nextThreadNum(), 0);
            }
         * 也就是说，在Thread的构造方法内传递一个Runnable对象的话，默认的启动线程就会执行该Runnable对象
         */
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //Thread的currentThread()得到当前线程的线程对象
                    System.out.println(Thread.currentThread().getName());
                }
            }
        });
        thread2.start();

        //我们可以看到两个线程交互跑了

        Thread thread3 = new Thread(new Runnable(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //Thread的currentThread()得到当前线程的线程对象
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //Thread的currentThread()得到当前线程的线程对象
                    System.out.println(Thread.currentThread().getName());
                }
            }
        };
        thread3.start();

        //这种执行的是哪里的代码呢？
        //很明显，这里Thread的Run方法被重写了，已经只是淡村的下面的run方法内容了，执行完毕，没有针对target.run()了，Runnable的run方法不会执行

        /**
         * 问题：
         *  1、多线程会提高程序的效率吗？
         *      一般不会的。一个cpu的情况下，多线程的执行就是在不同时间片段内执行不同的事，cpu切换需要损耗时间的，都是同样一个cpu，做同样的事，效率相同，一动不动做下去比多线程不会浪费切换的时间
         *  2、为什么会有多线程下载呢？
         *      多线程下载提高的不是本地的下载速度，而是服务器的带宽的分配情况。一个人它只会给你20kb，如果10个人请求它就给了你200kb，这样在服务器那端传输就变快了。
         */

    }
}