java多线程的创建

说多线程之前先说一下线程与进程的区别吧

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。（如图这就是进程，以及他们所占的内存空间）

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 （拿我们平时所用360举例子，他们的功能是可以同时进行的）

创建线程之前先说一下内存图解吧

这里是第一种创建线程的图解，在main方法中创建Thread子类的对象，然后在栈内存进行压栈，开启了主线程，堆内存中创建出了新对象的内存空间，此时需要注意用start（）方法开启新线程（在run（）方法中新线程任务为for循环），此时run（）方法重新开辟栈内存空间进行压栈，新线程创建成功。

下面说一下直接调用run（）方法会出现什么现象：

直接调用run（）方法，不会开启新线程，二是会在main方法（主线程）压栈之后，run（）也会跟着进行压栈，没有开辟新的栈内存，此时还是单线程。

下面来说如何创建线程

• 第一种：继承Thread方法。在Thread的子类中重写run方法，run方法中写需要开启的新线程。（本文的新线程的任务都是for循环打印）

package xiancheng;

public class DemoThread {
   public static void main(String[] args) {

       MyThread mt = new MyThread();

       mt.start();

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

package xiancheng;

public class MyThread extends Thread{

        //2.在Thread类的子类中重写Thread类中的run方法,设置线程任务
        @Override
        public void run() {
            for (int i = 0; i <5  ; i++) {
                System.out.println("run:"+i);
            }
        }
    }

结果：

由图可见，main线程与新线程任务，两个一起抢夺cpu的执行权限，所以他们的运行结果没有规律而言，就出现了随机打印的效果。

• 第二种：通过实现Runnable接口实现类来创建新线程

package Thread_Runnable;

/**
* 创建多线程的第二种方式：
* 1.创建Runnable的实现类
* 2.在实现中重写Runnable中抽象方法 run（）
* 3.创建Runnable接口实现类的对象
* 4.创建Thread类对象，在其构造方法中传入Runnable接口实现类的对象
* 5.调用Thread方法的start方法开启新线程执行run（）方法
*/
public class DemoRunnable {
   public static void main(String[] args) {

       RunnableImpl runnable = new RunnableImpl();
       Thread t = new Thread(runnable);

       t.start();
       for (int i = 0; i <5 ; i++) {
           System.out.println(Thread.currentThread().getName()+"----"+i);
       }

   }
}

package Thread_Runnable;

/**
 * 主线程
 */
public class RunnableImpl implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <5 ; i++) {
            System.out.println(Thread.currentThread().getName()+"----"+i);
        }


    }



}

结果：

这次的main方法比较给力，运行了好多次，依然是main方法先执行，不过读者们别误导，这个也是会随机打印结果的，新线程依旧会与main线程（主线程）去争夺cpu的执行权限。

• 第三种：匿名内部类实现线程创建，使用匿名内部类方式实现Runnable接口，重写Runnable中的run方法。（）

package Thread_NoNameInClass;

public class DemoNoNameInClass {

   public static void main(String[] args) {

       //线程的父类是Thread
       new Thread(){

           @Override
           public void run() {
               //设置线程任务
               for (int i = 0; i <5 ; i++) {
                   System.out.println(Thread.currentThread().getName()+"---"+i);

               }
           }
           //Thread子类对象需要调用Start方法开启线程
       }.start();

       //线程的接口Runnable  多态
       Runnable r = new Runnable(){
           //重写run方法，设置线程任务
           @Override
           public void run() {
               for (int i = 0; i <5 ; i++) {
                   System.out.println(Thread.currentThread().getName()+"---"+i);

               }

           }
       };
       //Thread类对象，传入实现类的参数，调用start开启线程
       new Thread(r).start();

   }
}

结果：

大家可以看到两个线程又出现了随机打印，这也是两个线程在争夺cpu的执行权限。

PS：三个测试代码中出现的不熟悉的方法均可在API文档中找到

（引用或转载请标明出处。谢谢。）