初见Java多线程

1.进程与线程

1.1 进程与线程的概念

Java的第一大特色:多线程编程的支持.

进程:可以理解为一个应用程序从开始到结束的执行过程,应用程序一旦运行,就是一个进程,每个进程都有自己独立的地址空间,每启动一个线程,系统就会为它分配地址空间,建立数据表来维护代码段、堆栈段和数据段。

线程:一个应用程序同时执行多个任务,通常,每一个任务就是一个线程.

       引入线程可提高程序并发执行的程度，可进一步提高系统效率 

联系:

• 一个进程至少包含一个主线程（线程数量大于等于1）。 
• 由于同一进程中的多个线程具有相同的地址空间，所以它们间的同步和通信也易于实现
• 同一进程或不同进程内的线程都可以并发执行

区别:

1. 执行开销:线程更"轻量级",创建,撤销一个线程比启动一个新线程开销要小的多
2. 执行过程:每一个进程可以说就是一个可执行的应用程序，每一个独立的进程都有一个程序执行的入口，顺序执行序列,但是线程不能够独立执行，必须依存在应用程序中,即没有进程就没有线程,进程一旦终止,其内的线程也将不复存在
3. 资源拥有:每个进程拥有自己的一整套变量,资源独立,无法共享,而线程则共享数据,共享变量使得线程之间的通信更有效,更方便.

4. 基本单位:进程是系统进行资源分配和调度的一个基本单位 
                  线程是cpu调度和分派的基本单位 
                 不管系统中是否有线程，进程都是拥有资源的独立单位

5. 创建:一个进程可创建一个或多个进程或线程 
           一个线程可创建一个或多个线程，但不可以创建进程

6. 地址空间:同一进程的所有线程共享本进程的地址空间，而不同的进程之间的地址空间是独立的。

那么多线程表现在哪呢?

在实际生活中,多线程非常有用,例如,一个浏览器可以同时下载多个图片和音乐,一个Web服务器需要同时处理多个并发的请求

1.2 多线程状态

 

线程共有创建,就绪,运行,阻塞,终止五种状态,用start()方法创建线程,进入就绪状态,然后通过系统调度进入运行状态,这时如果没有出现导致阻塞的事件线程就被终止了,如果出现了导致阻塞的事件,就进入了阻塞状态,当阻塞解除了又进入就绪状态,周而复始就是这样的一个过程.

2.Java多线程实现

2.1 继承Thread类实现多线程

java.lang.Thread是一个线程的核心类,新建一个线程最好的方法就是直接继承Thread类,而后覆写该类中的run()方法(就相当于主类中的main方法)

定义线程的主体类

package Thread;

/**
 * Author:weiwei
 * description:2019/2/15
 * Creat:多线程的实现
 **/

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 );
        }
    }
}

当现在有了线程的主体类之后，很自然我们就会想到产生线程类的实例化对象而后调用run()方法。实际上，我们不
能够直接去调用run()方法。

 观察调用run()方法

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

这个时候只是做了一个顺序打印，和多线程一点关系都没有。正确启动多线程的方式是调用Thread类中的start()方
法。

启动多线程：public synchronized void start()此方法会自动调用线程的run()方法

正确启动多线程

public class TestDemo {
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()接口实现多线程

Thread类的核心功能是进行线程的启动,如果一个类为了实现多线程直接去继承Thread类就会有单继承局限,在Java中又提供了另一个实现方法:Runnable()接口

利用Runnable接口实现线程主体类

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 = " + i);
        }
    }
}

这样写以后，新的问题就产生了。此时 MyThread 类继承的不再是Thread类而实现了Runnable接口，虽然解决了
单继承局限问题，但是没有start()方法被继承了。那么此时就需要关注Thread类提供的构造方法。

Thread类提供的构造方法:

public Thread(Runnable target)

可以接收Runnable接口对象。

启动多线程

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

这个时候就启动了多线程。多线程的启动永远都是Thread类的start()方法
这个时候需要注意的是，对于此时的Runnable接口对象可以采用匿名内部类或者Lambda表达式来定义。

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

package www.bit.java.testdemo;
public class TestDemo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World");
            }
        }).start();
    }
}

使用Lamdba表达式进行Runnable对象创建

package www.bit.java.testdemo;
public class TestDemo {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("Hello World");
        new Thread(runnable).start();
    }
}

在实际开发之中，大多采用的是以上两种操作来进行Runnable对象创建

2.3 Thread类与Runnable的区别

首先从使用形式来讲，明显使用Runnable实现多线程要比继承Thread类要好，因为可以避免但继承局限。
除了这点以外，Thread和Runnable还有什么区别呢？

来看Thread类的定义

public class Thread implements Runnable

Thread类是Runnable接口的子类,那么Thread类一定覆写了Runnable()接口的run()方法,结合之前的代码发现,使用Runnable实现的多线程的程序类可以更好的描述出程序共享的概念(并不是说Thread不能)

使用Thread实现数据共享(产生若干线程进行同一数据的处理操作)

package www.bit.java.testdemo;
class MyThread extends Thread {
    private int ticket = 10 ; // 一共10张票
    @Override
    public void run() {
        while(this.ticket>0){
            System.out.println("剩余票数："+this.ticket -- );
        }
    }}
public class TestDemo {
    public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
        new MyThread().start();
    }
}

剩余票数:9
剩余票数:8
剩余票数:7
剩余票数:6
剩余票数:5
剩余票数:4
剩余票数:3
剩余票数:2
剩余票数:1
剩余票数:10

 此时启动三个线程实现卖票处理。结果变为了卖各自的票。

使用Runnable实现共享

package www.bit.java.testdemo;
class MyThread implements Runnable {
    private int ticket = 10 ; // 一共10张票
    @Override
    public void run() {
        while(this.ticket>0){
            System.out.println("剩余票数："+this.ticket -- );
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread() ;
        new Thread(mt).start();
        new Thread(mt).start();
    }
}

剩余票数:10
剩余票数:10
剩余票数:9
剩余票数:8
剩余票数:7
剩余票数:6
剩余票数:9
剩余票数:8
剩余票数:5
剩余票数:7
剩余票数:6
剩余票数:5
剩余票数:4
剩余票数:3
剩余票数:2
剩余票数:1
剩余票数:4
剩余票数:3
剩余票数:2
剩余票数:1

Process finished with exit code 0

所以Runnable实现的多线程的程序类可以更好的描述出程序共享的概念

2.4 Callable实现多线程

从JDK1.5开始追加了新的开发包：java.uti.concurrent。这个开发包主要是进行高并发编程使用的，包含很多在高
并发操作中会使用的类。在这个包里定义有一个新的接口Callable

注意:

Runnable中的run()方法没有返回值，它的设计也遵循了主方法的设计原则：线程开始了就别回头。但是很多时候
需要一些返回值，例如某些线程执行完成后可能带来一些返回结果，这种情况下就只能利用Callable来实现多线
程。

使用Callable定义线程主体类。

class MyThread implements Callable<String> {
    private int ticket = 10 ; // 一共10张票
    @Override
    public String call() throws Exception {
        while(this.ticket>0){
            System.out.println("剩余票数："+this.ticket -- );
        }
        return "票卖完了，下次吧。。。" ;
    }
}

不管何种情况。如果要想启动多线程只有Thread类中的start()方法。

启动并取得多线程的执行结果

public class TestDemo {
    public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        FutureTask<String> task = new FutureTask<>(new MyThread()) ;
        new Thread(task).start();
        new Thread(task).start();
        System.out.println(task.get());
    }
}

以上形式主要是为了取得线程的执行结果。