多线程的两种创建方式

实现多线程的无返回值的两种方式:

• 继承(extends)Thread类;

• 实现Runnable接口.

继承Thread类方法的底层也是实现了Runnable接口的实现类它代表一个线程的实例,启动一个线程的唯一方式就是通过Thread类的start()实例方法.start()方法是一个native方法,它将启动一个线程.并执行run()方法.这种方式实现多线程很简单,通过自己的类直接继承Thread,并重写run()方法,就可以启动新线程并执行自己定义的run()方法.

单线程:也就是说程序执行的路径只有一条
多线程:程序的执行路径有多条.
并发和并行:表面上都是同事的意思.
                 前者强调的是逻辑上的同时,指的是同一时间内(同一时间段)同时发生
                 后者是物理上的同时,指的是同一个时间点(也就是同一时刻)上同时发生的(抢票,,,抢购,,,)
                 主线程:main方法所在的就是主线程
                 java虚拟机(jvm)就是一个多线程,至少开启了两个线程
                      第一个:main():主线程 Thread main
                      第二个:垃圾回收线程,保证及时回收不用的对象
                 那么java虚拟机是如何实现多线程的呢?
                      java语言是不能直接调用系统功能的(用系统功能创建对象),java语言可以通过c++/c 底层已经调用了系统功能,java提供了一个类

 Thread 类
          java虚拟机允许应用程序并发地运行多个执行线程
          多线程程序的开发步骤:
          1:自定义一个类,该类继承Thread类
          2:重写该类中的run方法
          3:主线程中去创建该类的对象
          4:启动线程.

//方式一:继承Thread类实现多线程
package Threaddemo;

class MyThread extends Thread {
    //无参构造
    public MyThread() {

    }

    //有参构造
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        //run方法中通常会加一些耗时操作,这样java虚拟机在调用该方法时才会出现CPU抢占时间片的随机操作
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

public class Thread1 {
    public static void main(String[] args) {
        //创建第一个线程对象
        MyThread th1 = new MyThread("线程1:");
        //创建第二个线程对象
        MyThread th2 = new MyThread("线程2:");
        //利用线程对象调用start方法开启线程,倘若我们利用对象去调用run方法就仅仅只是调用一个普通的类方法
        // th1.run();//相当于主线程main调用
        // th2.run(); 根据结果可以发现这种调用形式就是普通的类对象调用自己的普通的成员方法,并不会出现线程抢占CPU执行权的情况
        /*
        *   main0
            main1
            main2
            main3
            main4
            ...
        */
        th1.start();//线程1
        th2.start();//线程2 根据结果我们发现两个线程之间抢占CPU执行权的现象,线程1,2交叉执行,
        // 这是由于两个线程争先抢占CPU执行权所导致的结果
        /*
        *   线程1:0
            线程1:1
            线程1:2
            线程1:3
            线程2:0
            线程1:4
            线程2:1
            线程1:5
            线程2:2
            线程1:6
            线程2:3
            线程1:7
            线程2:4
            ...
        * */
    }
}

package Threaddemo;
/*
* 实现多线程的第二种方式:(开发中用的比较多)
* API描述
* 创建线程的另一种方法是声明实现Runnable接口的类
*    该类然后实现run方法,然后可以分配该类的实例,在创建时作为一个参数类传递并启动
*
*    方式2的开发步骤:
*       1:自定义一个MyRunnable(同一个资源)实现Runnable接口
*       2:实现Runnable里面的run方法,添加耗时操作
*       3:在主线程中创建MyRunnable类的对象
*       4:创建Thread类对象将第三步创建的对象作为参数进行传递来启动线程
*
* */
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+"---2018Love"+i);
        }
    }
}
public class MyThread2 {
    public static void main (String [] args){
        //创建MyRunnable对象
        MyRunnable my = new MyRunnable();
        //创建Thread对象
        Thread t1 = new Thread(my, "线程1");
        Thread t2 = new Thread(my, "线程2");
        //启动线程
        t1.start();
        t2.start();
    }
/*
结果:
线程1---2018Love0
线程1---2018Love1
线程1---2018Love2
线程1---2018Love3
线程1---2018Love4
线程1---2018Love5
线程1---2018Love6
线程1---2018Love7
线程1---2018Love8
线程1---2018Love9
线程1---2018Love10
线程1---2018Love11
线程1---2018Love12
线程1---2018Love13
线程1---2018Love14
线程1---2018Love15
线程1---2018Love16
线程1---2018Love17
线程1---2018Love18
* 
* */
}