Java的多线程和锁机制

一、前言

进程：在内存中运行的应用程序，每个进程都有自己独立的一块内存空间。
线程：进程中的一个执行任务单元，负责当前进程中程序的执行。

二、Java中线程的分类

java线程分为用户线程和守护线程

1.用户线程：在Java程序中创建一个线程，它就被称为用户线程。
2.守护线程：程序运行的时候在后台提供一种通用服务的线程，称为守护线程。
2.1特点：
当所有用户线程停止，进程就会停掉所有守护线程，退出程序。
Java把线程设置为守护线程的方法：用户线程在Start之前，调用线程的serDaemon（true）方法。
守护线程创建的线程也是守护线程，同时它不应该被访问，写入持久化资源，因为它会在任何时间段被停止，中断持久化。
例子：JVM中垃圾回收线程就是典型的守护线程。

三 、线程的状态

线程有6种状态

1.初始（New）
新创建了一个线程对象，但是没有调用start（）方法。
2.运行（Runnable）
Java线程将就绪（ready）和运行中（running）两种状态称为“运行”，线程创建后，调用start（）方法，此时线程位于可运行的线程池中，等待获取CPU的使用权，此时处于就绪状态（ready），当线程获取到CPU的使用权时，变为运行中（running）状态。
3.阻塞（Blocke）
指线程因为某种原因放弃CPU的使用权。比如：锁。
4、等待（Waiting）
进入该状态的线程，需要等待其它线程做出一些特定的动作。如：waiting（）方法。
5、超时等待（Timed_waiting）
该状态不同于Waiting，它可以在指定的时间后自动返回，争取CPU使用权。
6、终止（Terminated）
表示该线程已经执行完毕。

四、Java中线程的实现方式

一、Java中实现多线程有三种方式

1、继承Thread类
2、实现Runnable接口
3、实现Callable接口

1.1继承Thread类

class MyThread extends Thread{  // 继承Thread类，作为线程的实现类
    private String name ;       // 表示线程的名称
    public MyThread(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class ThreadDemo02{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象
        mt1.start() ;   // 调用线程主体
        mt2.start() ;   // 调用线程主体
    }
};

1.2程序的运行结果

2.1实现Runnable接口

package ljz;
class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类
    private String name ;       // 表示线程的名称
    public MyThread(String name){
        this.name = name ;      // 通过构造方法配置name属性
    }
    public void run(){  // 覆写run()方法，作为线程 的操作主体
        for(int i=0;i<10;i++){
            System.out.println(name + "运行，i = " + i) ;
        }
    }
};
public class RunnableDemo01{
    public static void main(String args[]){
        MyThread mt1 = new MyThread("线程A ") ;    // 实例化对象
        MyThread mt2 = new MyThread("线程B ") ;    // 实例化对象
        Thread t1 = new Thread(mt1) ;       // 实例化Thread类对象
        Thread t2 = new Thread(mt2) ;       // 实例化Thread类对象
        t1.start() ;    // 启动多线程
        t2.start() ;    // 启动多线程
    }
};

2.2程序的运行结果

3.1实现Callable接口

class ThreadDemo implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100000; i++) {
            System.out.println(i);
            sum += i;
        }
        return sum;
    }
}

public class TestCallable {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();

        // 1.执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果
        FutureTask<Integer> result = new FutureTask<>(td);
        new Thread(result).start();

        // 2.接收线程运算后的结果
        Integer sum;
        try {
            //等所有线程执行完，获取值，因此FutureTask 可用于 闭锁
            sum = result.get();
            System.out.println("-----------------------------");
            System.out.println(sum);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

二、创建线程三种方式的对比

实现Runnable/Callable接口相比继承Thread的优势
（1）适合多个线程进行资源共享（target对象能复用）
（2）避免Java中单继承的限制
（3）线程池只能放入Runnable和Callable接口的实现类，不能直接放入继承Thread的类

三、Callable和Runnable的区别

1.Callable重写的是call（）方法，Runnable重写的是run（）方法
2.call（）方法执行后有返回值，run（）方法没有返回值
3.call（）方法可以抛出异常，run（）方法不可以
4.运行callable可以拿到一个Future对象，表示异步计算的结果。通过Future对象可以了解任务执行情况，可以取消任务的执行和获取执行的结果。
PS：Callable的get（）方法，一般放在最后一行，因为执行get（）方法的时候，如果线程还没有执行完毕，get（）方法会阻塞main的主线程，直到拿到运行结果。

五、锁机制

参考文档：Java中各种锁的机制