[Java知识库]Java线程和他的六种状态简单介绍

1 什么是线程

线程是操作系统中能过被运行调度得最小得单位，他被包含在进程之中，是进程得执行单位，一条线程指的是进程中一个单一顺序的控制流。一个进程可以并发多个线程，而多个线程可以并行执行不同得任务，总结就是：

• 进程：是应用程序进入内存中，就是一个内存中运行的应用程序，比如QQ ，微信，网易云音乐
• 线程：线程属于进程，是进程的一个执行单元，负责程序的执行。(应用程序通向CPU的执行路径，CPU可以通过这个路径执行功能，这个功能又叫线程。)
• 进程是资源分配的最小单位，线程是CPU调度的最小单位
• 一个程序至少有一个进程，一个进程又至少有一个线程
• 线程的划分程度小于进程，使得多线程程序的并发性更高
• 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

分时调度：

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度：

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

创建线程

创建线程有四种方法，继承Thread类，实现Runnable接口，这两种方式都是没有返回值的，而实现Callable接口是具有返回值的，并且可以抛出异常，第四种就是使用线程池来创建了，需要的时候直接用就可以了，减少资源的消耗，想要更加详细的了解的话，可以去看看我的这一遍文章 ==> Java创建线程的四种方式。

2 并发和并行

• 并发：两个事件或多个事件交替执行，**在同一个时间段内发生。**重点在于他们是交替发生的，轮流交替，比如你一边喝水一遍吃零食，宏观上看你是同时在吃东西和喝水，但是实际上你是交替进行的，同一个时刻是做一件事情。
• 并行：两个事件或多个事件在同一时刻发生**（同时发生）**，重点是他们是同一个时刻发生的，比如你边写字边唱歌，这两件事情是在同一时刻发生的，这个就是并行，同时进行。

3 线程的状态

在Java中，线程被分成了六个状态，而在操作系统中，线程是被分成五个状态的，我们可以从java.lang.Thread.State类中可以看出：

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         * 线程的新生状态
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         * 线程运行中/等待
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         * 线程的阻塞状态
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         * 线程的等待态，死等，等，就应等
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         * 线程超时等待状态，超过一定的时间，就不在等待了
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         * 线程中止状态，代表线程执行完毕
         */
        TERMINATED;
    }

也就是说Java线程是由六个状态的：

• NEW：新建状态
• RUNNABLE：就绪/运行
• BOLCKED：阻塞状态
• WAITING：等待态
• TIMED_WAITING：超时等待
• TERMINATED：终止态

而操作系统的线程是只有五个状态的：

• NEW：初始状态，对应Java中的NEW状态
• READY：可运行状态，对应 Java中的 RUNNBALE状态
• RUNNING：运行状态，对应 Java中的RUNNBALE 状态
• WAITING：等待状态，该状态在 Java中被划分为了 BLOCKED，WAITING，TIMED_WAITING三种状态
• TERMINATED：终止状态

4 Synchronized 和 lock锁

synchronized 锁是什么

synchronized是Java中的一个关键字，是一个同步锁，我们为什么要使用他呢，在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即方法或者代码块在运行的时候只有一个能够进入临界区，他有三种应用方式：

• 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
• 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
• 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

8锁问题

这个我也会写一篇博客的，明天写，看完那篇博客，锁是啥子，就应该差不多了，哈哈哈，冲他。

synchronized锁的缺陷

• 被synchronized锁修饰的代码块或者方法，一旦拿到了对应的锁，那么释放锁资源的方式只有执行完了代码块释放，或者出现异常，jvm让线程自动释放锁，但是这个时候如果这个获取锁的线程被阻塞了，没有及时释放锁，那么其他需要这个锁的线程只可能干巴巴的等着这个锁，那么这个操作是十分消耗系统资源的，而lock可以自主释放锁，不让线程无休止的等下去。
• 多个线程读写一个文件时，应该是读读操作是兼容的，读写和写写操作是不兼容的，但是使用synchronized的话，读读操作都是不被允许的。

lock 锁是什么

lock锁，他是在jdk1.5之后，java.util.concurrent.locks包下的另外一种实现同步访问的技术，这个时候就会问了，有了synchronized锁了，为什么还有一个lock锁呢，因为lock锁可以做到synchronized锁做不到的东西，它可以很好的解决掉上面 synchronized 锁的缺陷。
通过查看他的源码可以知道，lock是一个接口:

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

那现在我们来对这六个方法来做一个解释

这里我们用一段代码来看看这些方法是如何使用的:

public class MyLock {

    private Lock lock = new ReentrantLock(); //定义一个全局的锁
    public static void main(String[] args) {
        final MyLock myLock = new MyLock(); //定义一个类调用方法
        new Thread(()->myLock.test(),"A").start();
        new Thread(()->myLock.test(),"B").start();
    }

    public void test(){
        //lock.lockInterruptibly();
        //可以在代码一开始就使用这个，直到获取到锁了，才执行，否则一直等待
        while (true){
            if(lock.tryLock()){  //尝试获取锁，得到啦
                System.out.println(Thread.currentThread().getName()+" ==> 获取到了锁");
                try {
                    //因为trylock尝试获取锁，返回true时就已经得到锁了，所以这里不需要在上锁，但是一般都是在try里面加锁
                    //lock.lock();
                    System.out.println(Thread.currentThread().getName()+"==>  我给自己加上lock锁");
                    Thread.sleep(10);
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    System.out.println(Thread.currentThread().getName()+"==>  释放了lock锁");
                    lock.unlock();  //finally 里释放锁
                    break;
                }
            }else{
                System.out.println(Thread.currentThread().getName()+" ==> 还在苦苦等待");
                try {
                    TimeUnit.MICROSECONDS.sleep(1000); //让程序睡眠1ms，便于观察结构
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

从上图我们可以看出，我们开启了两个线程，线程A首先获取锁，然后这个时候休眠，那么线程B就会被调用，但是他一直获取不到锁，所以一直在苦苦等待，直到A释放了锁，这个时候线程B才可以拿到锁，释放。

lock 和 synchronized 的区别

• lock不是java语言内置的，synchronized是java语言的关键字，因此是内置特性。lock是一个类，通过这个类可以实现同步访问。
• ck和synchronized有一点非常大的不同，采用synchronized不需要用户手动的去释放锁，当synchronized方法或者代码块执行完毕之后，系统会自动的让线程释放对锁的占有，而lock则必须要用户去手动释放锁，如果没有主动的释放锁，就会可能导致出现死锁的现象。

5 线程通信

多个线程并发执行的时候，在CPU中是随机切换的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有种方式。

• 利用 volatile 关键字
• 利用 Object类的 wait/notify 方法
• 通过 condition 的 await/signal 方法
• 通过 join 的方式

这个我两天内会写一篇比较详细的博客的，啦啦啦啦，现在晚上，休息，先把这一篇发出来。

6 线程中的常用方法

小结

线程的内容我现在写的就是这些了，为什么写了，最主要的还是因为我自己也不是特别了解了，在熟悉一下，加深印象，当然，写的不好，希望可以指出来哦，后面会逐渐完善，加新的内容滴。