开启多线程的旅途

说实话，听说多线程是个难点，所以我打算一点点啃，不求掌握多，只求精，慢慢来，老铁们，加油吧！

开始我们的旅途吧！

多线程

一.进程与线程的概念

进程：操作系统中一个程序的执行周期

线程：一个进程同时执行多个任务，通常来讲，每个任务就称为一个线程

1.与线程相比较，线程更加“轻量级”，创建，撤销一个线程比启动，撤销一个进程开销要小的多，一个进程中的所有线程共享此进程的所有资源

2.没有进程就没有线程，进程一旦终止，其内的线程也将不复存在

3.进程是操作系统资源调度的基本单位，进程可以独享资源，线程需要依托进程提供的资源，无法独立申请操作系统资源，是OS任务执行的基本单位

高并发：在同一时间有很多的线程

二.JAVA的多线程实现

2.1继承Thread类实现多线程

      java.lang.Thread是线程操作的核心类，新建一个线程最简单的方法就是直接继承Thread，而后覆写run（）方法（相当于主线程的main(）方法，既线程入口）

无论哪种方式实现多线程，线程启动一定掉用Thread类提供的start()方法

线程start方法只能调用一次，多次调用会java.lang.IllegalThreadStateException//状态非法异常

start(Java方法)->start0(JVM)->进行资源调度，系统分配（JVM）->run(JAVA方法)执行线程的具体操作任务

上代码：

package www.wl.java;
class MyThread extends Thread { // 线程主体类
    private String title ;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() { // 所有线程从此处开始执行
        for (int i = 0; i < 10 ; i++) {
            System.out.println(this.title+",i = " + i);
        }
    }
}

public class Test {
    public static void main(String[] args) {
                MyThread myThread1 = new MyThread("thread1") ;
                MyThread myThread2 = new MyThread("thread2") ;
                MyThread myThread3 = new MyThread("thread3");
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}

 

2.2实现Runnable接口来实现多线程

Tip:@FunctionalInterface检查接口中是否只有一个抽象方法

一言不合就上代码：
package www.wl.java;
class MyThread implements Runnable{
    private String title;

    public MyThread( String title) {
        this.title = title;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(this.title+","+i);
        }
    }
}
public class Test{
    public static void main(String[] args) {
        MyThread  mythread1 = new  MyThread("线程1");
        MyThread  mythread2 = new  MyThread("线程2");
        MyThread  mythread3= new  MyThread("线程3");
        //无论何种方法，启动线程必须使用Thread类提供的start()方法
       new Thread(mythread1).start();
        new Thread(mythread2).start();
        new Thread(mythread3).start();

    }
}

重点：此时MyThread类继承的不再是Thread类而实现了Runnable接口，虽然解决了单继

承局限问题，但是没有start()方法被继承了。那么此时就需要关注Thread类提供的构造方法。

Thread类提供的构造方法:

public Thread(Runnable target)

观察到Thread类可以接收Runnable接口对象

 

 

2.21 Runnable接口对象可以采用匿名内部类或者Lambda表达式来定义

使用匿名内部类进行Runnable对象创建

方法1：

public class Test {

public static void main(String[] args) {

new Thread(new Runnable() {

@Override

public void run() {

       System.out.println("Hello World");

             }

       }).start();

  }

}
方法2：
public class Test{
    public static void main(String[] args) {
       Runnable runnable = new Runnable() {
           //匿名内部类来实现Runnable接口
           @Override
           public void run() {
               System.out.println("hello");
           }
       };
       new Thread(runnable).start();
    }
}

方法3：

public class Test{
    public static void main(String[] args) {//函数式编程
        Runnable runnable = ()-> System.out.println("hello");
        new Thread(runnable).start();
    }
}

方法4：
public class Test{
    public static void main(String[] args) {//函数式编程
       
        new Thread(()-> System.out.println("hello")).start();//省略了匿名的Runnable对象实现
    }
}

 

2.3继承Thread类与实现Runnable接口的关系

A .Thread类与mythread（实现了Runnable接口）是一个典型的代理设计模式

Thread类负责辅助真实业务操作（资源调度，创建多线程并启动）

mythread负责真实业务的实现（run方法具体要干什么事）

B.使用Runnable接口实现的多线程程序类可以更好的描述共享的概念

package www.wl.java;
class MyThread implements Runnable {
    private Integer ticket = 10;
    private String title;

    public MyThread(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        for (int i =0;i<10;i++){
            System.out.println(this.title + "还剩下" + this.ticket--+"票");
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread mt= new MyThread("票贩子");//共享10张票
        Thread thread1 = new Thread(mt);
        Thread thread2 = new Thread(mt);
        Thread thread3 = new Thread(mt);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}