Java多线程

一：进程与线程

概述：几乎任何的操作系统都支持运行多个任务，通常一个任务就是一个程序，而一个程序就是一个进程。当一个进程运行时，内部可能包括多个顺序执行流，每个顺序执行流就是一个线程。

进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当程序进入内存运行时，即为进程。

进程的三个特点：

1：独立性：进程是系统中独立存在的实体，它可以独立拥有资源，每一个进程都有自己独立的地址空间，没有进程本身的运行，用户进程不可以直接访问其他进程的地址空间。

2：动态性：进程和程序的区别在于进程是动态的，进程中有时间的概念，进程具有自己的生命周期和各种不同的状态。

3：并发性：多个进程可以在单个处理器上并发执行，互不影响。

并发性和并行性是不同的概念：并行是指同一时刻，多个命令在多个处理器上同时执行；并发是指在同一时刻，只有一条命令是在处理器上执行的，但多个进程命令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果

线程：线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。

线程的特点：

线程可以完成一定任务，可以和其它线程共享父进程的共享变量和部分环境，相互协作来完成任务。

线程是独立运行的，其不知道进程中是否还有其他线程存在。

线程的执行是抢占式的，也就是说，当前执行的线程随时可能被挂起，以便运行另一个线程。

一个线程可以创建或撤销另一个线程，一个进程中的多个线程可以并发执行。

二：线程的创建及使用

java使用Thread类代表线程，所有的线程对象都必须是Thread或者其子类的实例，每个线程的作用是完成一定任务，实际上是就是执行一段程序流（一段顺序执行的代码）

方案一：继承Thread类创建线程类

步骤：1.定义Thread类的子类并重写该类的Run方法，该run方法的方法体就代表了该线程需要完成的任务

2.创建Thread类的实例，即创建了线程对象

3.调用线程的start方法来启动线程

package Thread01;
 
public class MyThread extends Thread {
    private int i;
 
    @Override
    public void run() {
       for (; i < 10; i++) {
         System.out.println(getName()+"\t"+i);
    }
    }
}

测试方法

package Thread01;
 
public class MyTest {
    public static void main(String[] args) {
        for (int i = 0; i <10; i++) {
             System.out.println(Thread.currentThread().getName()+"\t"+i);
             if(i==5){
                 MyThread mt=new MyThread();
                 MyThread mt2=new MyThread();
                 mt.start();
                 mt2.start();
             }
        }
    }
}

方案二：实现Runnable接口

1：定义Runnable接口的实现类，并重写它的Run方法，run方法同样是该线程的执行体！

2：创建Runnable实现类的实例，并将此实例作为Thread的target创建一个Thread对象，该Thread对象才是真正的线程对象！

3：调用start方法启动该线程

package Thread02;
 
public class SecondThread implements Runnable{
    private int i;
    public void run() {
        for (; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20)
            {
                System.out.println(Thread.currentThread().getName()+"执行完毕");
            }
        }
    }
}

测试方法

package Thread02;
 
public class MyTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==5)
            {
                SecondThread s1=new SecondThread();
                Thread t1=new Thread(s1,"线程1");
                Thread t2=new Thread(s1,"线程2");
                t1.start();
                t2.start();
 
            }
        }
    }
}

结论：采用Ruunable接口的方式创建多个线程可以共享线程类的实例变量，这是因为在这种方式下，程序创建的Runnable对象只是线程的target，而多个线程可以共享一个target，所以多个线程可以共享一个实例变量

通过Runnable实现多线程其实就是将run包装成线程的执行体，但是目前java无法将任意方法包装成线程执行体

方案三：使用callable和future创建线程

从Java5开始，Java提供 Callable接口,Callable接口提供了一个call（）方法可以作为线程执行体，看起来和Runnable很像，但call（）方法更强大——call（）方法可以有返回值、call（）方法可以抛出异常

Java5提供了Future接口来代表Callable接口的call（）方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现类Future接口，也实现了Runnable接口——可以作为Thread的target。

实现步骤：

1：创建Callable接口的实现类，并实现call方法，该call方法会成为线程执行体，且call方法具有返回值，在创建callable接口的实现类！

2：使用FutrueTask类来包装Callable对象，该FutrueTask封装类Callable的call方法的返回值

3：使用FutrueTask对象作为Thread的target创建并启动新线程！

4：使用FutrueTask的get方法获取执行结束后的返回值

package Thread03;
 
import java.util.concurrent.Callable;
 
public class Target implements Callable<Integer> {
    int i=0;
    public Integer call() throws Exception {
        for (; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+""+i);
        }
        return i;
    }
 
}

测试方法

package Thread03;
 
import java.util.concurrent.FutureTask;
 
public class ThirdThread {
     public static void main(String[] args) {
            Target t1=new Target();
            FutureTask<Integer> ft=new FutureTask<Integer>(t1);
            Thread t2=new Thread(ft,"新线程");
            t2.start();
            try {
                System.out.println(ft.get());
            } catch (Exception e) {
            }
    }
}

结论：采取Runnable、Callable的优势在于——线程类只是实现了Runnable或Callable接口，还可以继承其它类；在这种方法下，多个线程可以共享一个target对象，因此非常适合多个相同线程处理同一份资源的情况，从而将CPU、代码和数据分开，形参清晰的模型，体现了面对对象的编程思想。劣势在于编程复杂度略高。

三：线程的状态

当线程被创建并被启动时，它既不是一启动就进入了执行状态，在线程的生命周期中，它要经过new(新建)，就绪（Runnable），运行（Running），阻塞(Blocked)，dead(死亡)。

当线程启动之后，它不可能一直霸占着cpu独自运行，所有cpu需要在多条线程轮流切换，于是线程就也会多次在运行.就绪之间切换

1：新建和就绪状态

--新建状态：

当程序使用new关键字创建了一个线程时，该线程就处于新建状态。

此时的它和其它java对象一样，仅有虚拟机分配内存，并初始化成员变量的值。此时的线程对象并没有表现出线程的任何动态特征，程序也不会执行线程的线程执行体

--就绪状态：

当线程对象调用了start()方法后，该线程就处于就绪状态，java虚拟机会为其创建方法调用栈和程序计数器，处于该状态的线程并没有开始执行，只是表明该线程可以运行了，至于该线程何时运行，取决于JVM的调度。

注意！！！

启动线程要调用start方法，而不是run方法，永远不要调用线程的run方法，如果调用run方法，系统会把线程对象当作普通的对象，会吧线程的执行体当作普通方法来调用！在调用了run方法之后，该线程就不在处于新建状态，不要再调用该线程的start方法！java中只能对处于新建状态的线程使用start方法，否则将会引发IllegalThreadStateException异常！