多线程的实现方案(掌握)
                A:继承Thread类
                        1,自定义MyThread继承Thread类，
                        2，MyThread类里面重写run()方法，
                                public class MyThread extends Thread{
                                        public void run(){
                                                for(int x=0;x<100;x++){
                                                        System.out.println(x);
                                                }
                                        }
                                }
                        3，创建对象。
                        4，启动线程。
                                public static void main(String[] args){
                                        //创建线程对象
                                        MyThread my1=new MyThread();
                                        MyThread my2=new MyThread();
                                        //调用方法设置名称
                                        my1.setName("线程一");
                                        my2.setName("线程二");
                                        //启动线程
                                        my1.start();
                                        my2.start();
                                       
                                }
                               
                        面试题：run()和start()的区别？
                        run():仅仅是封装被线程执行的代码，直接调用run()方法就是普通方法了。
                        start();首先启动线程，然后再有jvm去调用该线程的run()方法
                B:实现Runnable接口
        总结：实现多线程的两种方式
                方式一：继承Thread类
                        A:自定义MyThread继承Thread类。
                        B:在MyTHread类中重写run()方法。
                        C:创建MyThread类的对象。
                        D:启动线程对象。
                方式二：实现Runable接口
                        A:自定义类MyRunnable实现Runnable接口
                        B:在MyRunnable里面重写run()
                        C:创建MyRunnable类的对象
                        D:创建Thread类的对象，并把C步骤的对象作为构造参数传递,启动线程。
                代码对比
                方式一
                MyThread my1=new MyThread();
                MyThread my2=new MyThread();
                my1.setName("线程一");
                my2.setName("线程二");
                my1.start();
                my2.start();
                方式二
                MyRunnable mr1=new MyRunnable();
                MyRunnable mr2=new MyRunnable();
                Thread t1=new Thread(my1,"线程一")
                Thread t2=new Thread(my2,"线程二")
                t1.start();
                t2.start();
                问题：a，为什么要重写run方法？                run里面封装的是要被线程执行的代码。
                        b，启动线程对象用的是那个方法？          start()。
                        c，run和start方法的区别？             run直接调用仅仅是普通方法，start会先启动线程，再有jvm调用run方法。
                        d，有了方式一问什么还要有方式二呢？
                                1，实现Runable接口可以避免由于java单继承带来的局限性。
                                2，适合多个相同程序的代码去处理同一个资源的情况，把线程同程序代码数据有效分离，降低了耦合性，较好的体现了面向对象的设计思想。

多线程的实现方案(掌握)
                A:继承Thread类
                        1,自定义MyThread继承Thread类，
                        2，MyThread类里面重写run()方法，
                                public class MyThread extends Thread{
                                        public void run(){
                                                for(int x=0;x<100;x++){
                                                        System.out.println(x);
                                                }
                                        }
                                }
                        3，创建对象。
                        4，启动线程。
                                public static void main(String[] args){
                                        //创建线程对象
                                        MyThread my1=new MyThread();
                                        MyThread my2=new MyThread();
                                        //调用方法设置名称
                                        my1.setName("线程一");
                                        my2.setName("线程二");
                                        //启动线程
                                        my1.start();
                                        my2.start();
                                       
                                }
                               
                        面试题：run()和start()的区别？
                        run():仅仅是封装被线程执行的代码，直接调用run()方法就是普通方法了。
                        start();首先启动线程，然后再有jvm去调用该线程的run()方法
                B:实现Runnable接口
        总结：实现多线程的两种方式
                方式一：继承Thread类
                        A:自定义MyThread继承Thread类。
                        B:在MyTHread类中重写run()方法。
                        C:创建MyThread类的对象。
                        D:启动线程对象。
                方式二：实现Runable接口
                        A:自定义类MyRunnable实现Runnable接口
                        B:在MyRunnable里面重写run()
                        C:创建MyRunnable类的对象
                        D:创建Thread类的对象，并把C步骤的对象作为构造参数传递,启动线程。
                代码对比
                方式一
                MyThread my1=new MyThread();
                MyThread my2=new MyThread();
                my1.setName("线程一");
                my2.setName("线程二");
                my1.start();
                my2.start();
                方式二
                MyRunnable mr1=new MyRunnable();
                MyRunnable mr2=new MyRunnable();
                Thread t1=new Thread(my1,"线程一")
                Thread t2=new Thread(my2,"线程二")
                t1.start();
                t2.start();
                问题：a，为什么要重写run方法？                run里面封装的是要被线程执行的代码。
                        b，启动线程对象用的是那个方法？          start()。
                        c，run和start方法的区别？             run直接调用仅仅是普通方法，start会先启动线程，再有jvm调用run方法。
                        d，有了方式一问什么还要有方式二呢？
                                1，实现Runable接口可以避免由于java单继承带来的局限性。
                                2，适合多个相同程序的代码去处理同一个资源的情况，把线程同程序代码数据有效分离，降低了耦合性，较好的体现了面向对象的设计思想。