java 多线程 start方法 run方法 简单介绍。

一 start开启一个多线程， run 只是一个内部的方法。

package com.aaa.threaddemo;
/*
 *   start方法的作用？
 *       在 Java中启动多线程调用的是start方法。
 *      在start方法中，真正实现多线程的是一个本地的方法start0。
 *      调用start方法启动一个线程，此时的状态是  就绪。
 *      无需等待run方法体代码执行完毕，可以继续执行下面的代码。
 *      被synchronized 修饰， 线程是安全的
 *      由jvm创建的main方法线程和system组线程，并不会通过start来启动。
 *      等到run方法run 下结束，线程终止。start方法不可使用两次。
 *    
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

    private native void start0();
    
    
    run方法？
        run()方法只是一个类中的普通方法，调用run方法跟调用普通方法一样
        方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了  【运行状态】，开始运
        行 run 函数当中的代码。 
        Run 方法运行结束， 此线程终止。再调用start方法报错的。
        然后 CPU 再调度其它线
        
   
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }   
 * 
 */
public class StartDemo {
    public static void main(String[] args) {
        
        Runnable rdemo = new  Runnable() {
            public void run() {
                String name = Thread.currentThread().getName();
                System.out.println("当前运行的线程 ： " + name);
            }
        };
        
        rdemo.run();
        
        // 开启多线程，执行run方法
        new Thread(rdemo).start();    
    }
}

二  直观比较run方法和start。

package com.aaa.threaddemo;
/*
 *   start方法的作用？
 *       在 Java中启动多线程调用的是start方法。
 *      在start方法中，真正实现多线程的是一个本地的方法start0。
 *      调用start方法启动一个线程，此时的状态是  就绪。
 *      无需等待run方法体代码执行完毕，可以继续执行下面的代码。
 *      被synchronized 修饰， 线程是安全的
 *      由jvm创建的main方法线程和system组线程，并不会通过start来启动。
 *      等到run方法run 下结束，线程终止。start方法不可使用两次。
 *    
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

    private native void start0();
    
    
    run方法？
        run()方法只是一个类中的普通方法，调用run方法跟调用普通方法一样
        方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了  【运行状态】，开始运
        行 run 函数当中的代码。 
        Run 方法运行结束， 此线程终止。再调用start方法报错的。
        然后 CPU 再调度其它线
        
   
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }   
 * 
 */
public class StartDemo {
    public static void main(String[] args) {
                // 调用的是类中的一个普通方法run
                runDemo runDemo = new runDemo();
                runDemo.run();
                
                //开启多线程
                runDemo.start();
                //线程已经结束，二次执行会报错
                runDemo.start();    
    }
}

/*
 * 
     Runnable rdemo = new  Runnable() {
            public void run() {
                String name = Thread.currentThread().getName();
                System.out.println("当前运行的线程 ： " + name);
            }
        };
        
        rdemo.run();
        
        // 开启多线程，执行run方法
        new Thread(rdemo).start();    
 * 
        //  这里是new 一个Thread， 可以继续调用start方法。
        new Thread(rdemo).start();
        
        
        
 */
class runDemo extends Thread{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("run show" + Thread.currentThread().getName());
    }
}

 

三  新建线程，start 方法可再次使用

package com.aaa.threaddemo;
/*
 *   start方法的作用？
 *       在 Java中启动多线程调用的是start方法。
 *      在start方法中，真正实现多线程的是一个本地的方法start0。
 *      调用start方法启动一个线程，此时的状态是  就绪。
 *      无需等待run方法体代码执行完毕，可以继续执行下面的代码。
 *      被synchronized 修饰， 线程是安全的
 *      由jvm创建的main方法线程和system组线程，并不会通过start来启动。
 *      等到run方法run 下结束，线程终止。start方法不可使用两次。
 *    
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }

    private native void start0();
    
    
    run方法？
        run()方法只是一个类中的普通方法，调用run方法跟调用普通方法一样
        方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了  【运行状态】，开始运
        行 run 函数当中的代码。 
        Run 方法运行结束， 此线程终止。再调用start方法报错的。
        然后 CPU 再调度其它线
        
   
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }   
 * 
 */
public class StartDemo {
    public static void main(String[] args) {
        
         
         Runnable rdemo = new  Runnable() {
                public void run() {
                    String name = Thread.currentThread().getName();
                    System.out.println("当前运行的线程 ： " + name);
                }
            };
            
            rdemo.run();
            
        // 开启多线程，执行run方法
        new Thread(rdemo).start();    
     
        //  这里是new 一个Thread， 可以继续调用start方法。
        new Thread(rdemo).start();
        
        
        // 调用的是类中的一个普通方法run
        runDemo runDemo = new runDemo();
        //开启多线程
        runDemo.start();
        //线程已经结束，二次执行会报错
        runDemo.start();    
    }
}
class runDemo extends Thread{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("run show" + Thread.currentThread().getName());
    }
}