Java线程原理及详解

Java 多线程

线程和进程

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

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

主线程：在Java中必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束。这个线程在java中称之为主线程。

多线程原理：多线程是通过并发的方式进行。对于一个CPU它在某个时间点上，只能执行一个程序，即同一时间只能运行一个进程，CPU会不断地在这些进程之间切换，每个线程执行一个时间。因为CPU的执行速度相对我们的感觉实在太快了，虽然CPU在多个进程之间轮换执行，但我们自己感到好像多个进程在同时执行。

CPU会在多个进程之间做着切换，如果我们开启的程序过多，CPU切换到每一个进程的时间也会变长，我们也会感觉机器运行变慢。所以合理的使用多线程可以提高效率，但是大量使用，并不能给我们带来效率上的提高。

线程状态转换

 

1、新建状态(New): 新创建了一个线程对象。

2、就绪状态(Runnable): 线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态（Running）： 就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）

5、死亡状态（Dead）： 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

创建线程

Java创建线程的四种方式：1.继承Thread类覆写run()方法实现多线程 2.实现Runnable()接口实现多线程，而后同样覆写run()方法 3.实现Callable接口覆写call()方法实现多线程 4.通过线程池启动多线程

1.继承Thread类实现多线程

• 创建线程的步骤：

• 定义一个类继承Thread。

• 重写run()方法。

• 创建子类对象，就是创建线程对象。

• 调用start()方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

``` p

class Dem1 extends Thread{//继承Thread类
        private  String name;
        Dem1(String name){
            this.name=name;
        }

    @Override
    public void run() {//重写run方法
        for (int i=0;i<3;i++){
            //Thread.currentThread().getName() 获得当前线程对象 名称
            System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
        }
    }
}

public class ThreadDem1 {
    public static void main(String[] args) {
        Dem1 d1=new Dem1("张三");//创建对象
        Dem1 d2=new Dem1("李四");//创建对象
        d1.run(); //对象直接执行run方法
        d1.start();//start方法开启线程执行run方法
        d2.start();//start方法开启线程执行run方法
       
    }
}
```

 

main方法中程序由主线程执行，当开启多个线程时，线程间互相切换。

注意：当主线程执行完成了，并不代表程序就结束，如果此时还有其他线程正常执行，程序仍然在执行过程中。当任何一个线程出现了异常，其他线程还是会继续运行的。异常只会影响到异常所属的那个线程。

 

```p

class Dem1 extends Thread{
        private  String name;
        Dem1(String name){
            this.name=name;
        }

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

class Dem2 extends Thread{
    private  String name;
    Dem2(String name){
        this.name=name;
    }

    @Override
    public void run() {
        System.out.println(2/0);//会发生异常的代码
        System.out.println(name);
    }
}

 

public class ThreadDem1 {
    public static void main(String[] args) {
        Dem1 d1=new Dem1("张三");
        Dem2 d2=new Dem2("李四");
       
        d2.start();
        d1.start();
       
    }
}

```

 

程序执行时由于d2开启的线程中发生了异常，线程终止，该对象的"name"属性并没有被输出，但该线程异常后并没有影响其他线程的运行，d1开启的线程正常执行。

2.实现Runnable接口

• 定义类实现Runnable接口。
• 覆盖接口中的run方法。
• 创建Thread类的对象。
• 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
• 调用Thread类的start方法开启线程。

```p

public class TreadDem2 {
    public static void main(String[] args) {
        Dem3 d1=new Dem3();//创建对象
        Dem3 d2=new Dem3();//创建对象
        Thread t1=new Thread(d1);//类对象作为参数传递给Thread类的构造函数
        Thread t2=new Thread(d2);//类对象作为参数传递给Thread类的构造函数
        t1.start();//开启线程
        t2.start();//开启线程
    }
}

class Dem3 implements Runnable{//实现 Runable接口
    private String name;

    @Override
    public void run() {//覆写run方法
        for (int i=0;i<10;i++){
            System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
        }
    }
}

```

 

3.实现Callable接口

Callable接口是Java5新增的接口，它不是Runnable接口的子接口，所以就不能作为Thread的target。但call()方法还有一个返回值，如何获取这个返回值呢？Java5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，同时也实现了Runnable接口（可以作为Thread类的target了）

Future 接口定义了如下几个公共方法来控制它关联的Callable任务：
（1）boolean cancel(boolean mayInterruptIfRunning)：试图取消该Future里关联的Callable任务。
（2）V get()：返回Callable任务里call()方法的返回值。调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值。
（3）V get(long timeout,TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间。如果经过指定时间Callable任务依然没有返回值，将会抛出TimeoutException异常。
（4）boolean isCancelled()：如果在Callable任务正常完成前被取消，则返回true。
（5）boolean isDone()：如果Callable任务完成，返回true。

```p

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName()+" "+i);
                sum += i;
        }
        return sum;
    }
}

public class ThreadDemo4 {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        Thread t=new Thread(futureTask);
        t.start();

        try {
            //6.获取Callable中call方法的返回值(如果对call方法的返回值不感兴趣，就不需要调用futureTask.get()方法)
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

```