Java类库之线程

概念分析

在对线程进行分析之前，我们先要了解几个概念：
并行：指两个或者多个事件在同一时刻发生；
并发：指连个或多个事件在同一时间段发生；

在操作系统中，在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但是在单CPU中，每一时刻却只能有一道程序执行，故微观上这些程序只能分时的交替执行。

---

进程：指一个内存中的应用程序，每个进程都有一块自己独立的内存空间，一个应用程序可以启动多个进程。
线程：进程中的一个执行任务（控制单元），一个进程可以同时并发运行多个线程。
进程和线程的区别:
进程有独立的内存空间，进程中的数据存放空间是独立的，一个进程至少有一个线程。（空间：这里指的是堆空间和栈空间；堆空间是共享的，栈空间是独立的）
线程消耗的资源比进程小，线程之间可以进行相互的影响，又称为轻型进程或进程元。
那么线程又是怎么执行的呢？其实从微观考虑，线程的执行顺序也是有先后顺序的，那么哪个线程执行完全取决于CPU调度器（在java中由JVM来调度），这个执行顺序是程序员控制不了的。当然我们可以把多个线程的并发性是多个线程瞬间抢CPU资源，谁抢到资源就谁执行，这也造就了多线程的随机性。（在Java程序的进程里必须包含主线程和垃圾回收线程）；

---

线程调度:
计算机只有一个CPU时，在任意时刻只能执行一条计算机指令，每一个进程只有获取到CPU执行权限才能执行指令。所谓的多进程并发运行，从宏观上看其实是各个进程轮流获得CPU的使用权限，分别执行各自的任务。那么在可运行池中，会有多个线程处于就绪状态等待CPU（JVM）的执行。这样CPU（JVM）就负责了线程的调度。

---

多线程的优势：
多线程作为一种多任务、并发的工作方式，当然有其存在的优势：
- 1.进程之间不能共享内存，而线程之间共享内存（堆内存）很简单。
- 2.系统创建进程时需要为进程重新分配系统资源，创建线程则代价小很多。因此实现多任务并发时，多线程的效率更高。
- 3.Java语言本身内置了多线程功能 支持，而不是单纯的作为系统的调用方式，是由JVM进行调度的，从而简化了多线程编程。

---

如何创建进程和线程：

创建进程
通过Runtime或者ProcessBuilder类来开启一个进程

public class CreateProcess {
    public static void main(String[] args) throws IOException {
        //方式一：通过Runtime
        //获得Runtime对象
        Runtime runtime = Runtime.getRuntime();
        runtime.exec("notepad");
        //方式二：通过ProcessBuilder
        ProcessBuilder proB = new ProcessBuilder("notepad");
        proB.start();

    }
}

创建线程和启动线程

通过Javaapi可以发现创建线程有那种传统方式，我们也就通过这两种方式来进行演示；
- 1.通过继承Thread类：
注意：启动线程用start方法来启动线程；run方法就是该线程的执行体（也就是说开启该线程来执行什么任务就写在run方法中）；

public class CreateThread {
    public static void main(String[] args) {
        Thread thread = new SonThread();//创建线程，此时线程处于Java中的创建态
        thread.start();//开始线程，此时该线程处于Java当中的运行态
    }
}

class SonThread extends Thread{
    public SonThread(){
        this.setName("sonThread");
    }
    @Override
    public void run() {
        System.out.println(this.getName()+":sonThread线程已经创建了");
    }
}

• 2.通过实现Runnable接口：
  由于通过实现Runnable的类本身并不是Thread类，所有不能直接获取线程的名字和修改线程的名字。因此我们采用Thread类提供的静态方法currentThread方法获取当前线程来获取当前线程的名字；

public class CreateThread {
    public static void main(String[] args) {
        new Thread(new SonThread2()).start();
    }
}

class SonThread2 implements Runnable{

    public SonThread2(){
        Thread.currentThread().setName("SonThread2");
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":SonThread2线程已经被创建了");
    }

}

继承Thread方式和实现Runnable方式的区别：

继承Thread方式：
- Java中类是单继承的，如果继承了Thread了，该类就不能再有其他直接父类了。
- 从操作上分析，继承的方式更简单，获取线程的名称也简单
- 从多线程共享同一个资源上分析，继承的方式不能做到共享同一个资源
实现Runnable方式：
- Java中类可以多实现接口，此时该类还可以继承其他类，并且还可以实现其他接口
- 从操作上分析，实现的方式稍简复杂，获取线程的名称需要使用Thread.currentThread();来获取当前线程的引用
- 从多线程共享同一个资源上分析，实现的方式能做到共享同一个资源

---

线程不安全问题

多线程访问同一个资源对象的时候，可能出现线程不安全的问题
下面代码来演示线程不安全的问题：

public class TestThreadProblem {
    public static void main(String[] args) {
        Student st = new Student();
        new Thread(st,"A同学").start();
        new Thread(st,"B同学").start();
        new Thread(st,"C同学").start();
    }
}

class Student implements Runnable{
    private int AppleNum = 50;//假设有50个苹果

    @Override
    public void run() {
        for(int i=0;i<50;i++){
            if(AppleNum>0){
                System.out.println(Thread.currentThread().getName()+"吃了编号为："+AppleNum+"的苹果");
                AppleNum--;
            }
        }
    }

}

通过这个程序我们可以发现线程出现了不安全的问题：

线程安全问题产生的异常结果中一部分：
A同学吃了编号为：50的苹果
B同学吃了编号为：50的苹果
B同学吃了编号为：48的苹果

通过上面程序的异常结果我们发现，当A同学开始打印吃了几号苹果的时候，此时B同学也进入到程序中，当A同学还没有对苹果编号进行减1，此时B同学就打印出来吃了苹果的编号。

---

通过上面的程序我们发现，当多线程共享资源的时候（也就是并发的时候），会出现线程不安全问题,那么我们该怎样解决这种问题呢？
解决方式有三种：
- 同步代码块
- 同步方法
- 锁机制（Lock:该接口是在Java5后出现的，用于取代synchronized）

---

解决线程不安全问题

同步代码块
为了保证每个线程都能执行原子操作，Java引入了线程同步机制：
语法：
synchronized(同步锁){
需要同步操作的代码
}
注意：在任何时候，最多允许一个线程拥有同步锁进入代码块，其他线程只能在外面等待
解决刚才线程不安全的问题：

public class TestSynchronized {
    public static void main(String[] args) {
        Student st = new Student();
        new Thread(st, "A同学").start();
        new Thread(st, "B同学").start();
        new Thread(st, "C同学").start();
    }
}

class Student implements Runnable {
    private int AppleNum = 50;// 假设有50个苹果

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            synchronized (this) {
                if (AppleNum > 0) {
                    System.out.println(Thread.currentThread().getName() + "吃了编号为：" + AppleNum + "的苹果");
                    AppleNum--;
                }
            }
        }
    }

}

同步方法
使用synchronize修饰的方法就叫做同步方法，如果一个线程在执行该方法的时候，其他线程就只能在方法外等待。
语法：
synchronized public void fun(){
方法中的代码
}
注意：不要用synchronize修饰run方法，修饰run会让某一线程执行了所有的操作后，才能让另一个线程开始来执行。
使用静态方法解决刚才的问题：

public class TestSynchronized {
    public static void main(String[] args) {
        Student st = new Student();
        new Thread(st, "A同学").start();
        new Thread(st, "B同学").start();
        new Thread(st, "C同学").start();
    }
}

class Student implements Runnable {
    private int AppleNum = 50;// 假设有50个苹果

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            eatApple();
        }
    }

    synchronized private void eatApple(){
            if (AppleNum > 0) {
                System.out.println(Thread.currentThread().getName() + "吃了编号为：" + AppleNum + "的苹果");
                AppleNum--;
            }
    }

}

锁机制（Lock）
Lock机制提供了比synchronized和synchronized方法更为广泛的锁定操作，同步代码块和同步方法所具有的功能，Lock都有，除此之外更强大，更能体现面向对象。
使用同步锁，需要先声明锁，在需要加锁的方法中的加锁，最后再释放锁。
通过锁机制解决上面的问题：

public class TestLock {
    public static void main(String[] args) {
        Student st = new Student();
        new Thread(st, "A同学").start();
        new Thread(st, "B同学").start();
        new Thread(st, "C同学").start();
    }
}

class Student implements Runnable {
    private int AppleNum = 50;// 假设有50个苹果
    private final Lock lock = new ReentrantLock();//创建一个锁
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            eatApple();
        }
    }

    private void eatApple(){
        //加锁
        lock.lock();
        try{
            if (AppleNum > 0) {
                System.out.println(Thread.currentThread().getName() + "吃了编号为：" + AppleNum + "的苹果");
                AppleNum--;
            }
        }finally{
            //释放锁
            lock.unlock();
        }
    }

}

synchronized和Lock的区别
关于Synchronized和Lock的区别大家可以参考一下比较好的博客：https://blog.csdn.net/u012403290/article/details/64910926?locationNum=11&fps=1
这里再给出一篇关于synchronized的详解博客，个人看了绝对很受用，大家也可以去看一下(https://blog.csdn.net/javazejian/article/details/72828483)[https://blog.csdn.net/javazejian/article/details/72828483]

单例模式中的饿汉模式和懒汉模式

• 饿汉模式

public class Singleton {  
    private static final Singleton singleton = new Singleton();  
    //限制产生多个对象  
    private Singleton(){}  
    //获取实例对象  
    public static Singleton getSingleton(){  
        return singleton;  
    }  
} 

• 懒汉模式

    public class Singleton {  
        private static Singleton singleton = null;  
        //限制产生多个对象  
        private Singleton(){}  
        //获取实例对象  
        public static Singleton getSingleton(){  
            if(singleton == null){  
                singleton = new Singleton();  
            }  
            return singleton;  
        }  
    }  

通过观察这两种设计单例模式：懒汉式单例在低并发的情况下应该不会出现问题，但是系统压力增大会有线程安全的问题。

解决方法：
在获取实例对象中添加同步方法：

public class Singleton {  
        private static Singleton singleton = null;  
        //限制产生多个对象  
        private Singleton(){}  
        //获取实例对象  
        synchronized public static Singleton getSingleton(){  
            if(singleton == null){  
                singleton = new Singleton();  
            }  
            return singleton;  
        }  
    }  

但是上面的解决方法会让性能很低。所有还是建议使用饿汉模式。

线程的生命周期

Java中的线程生命周期存在以下六种状态：

其实通过上面图发现Java中的线程状态和操作系统中的线程状态有所不同，其实仔细分析也没有很多的差距。

在Java官网中对Java线程的生命周期分为了六种状态：

• 新建状态（NEW）：使用new创建的一个线程对象，只是在堆中分配内存空间，在调用start()方法之前。
• 可运行状态（RUNNABLE）：分为两种状态，READY和RUNNING。分别表示就绪状态和运行状态。
  
  • 就绪状态：线程对象调用start方法之后（注意：线程只能被启动一次，也就是说该线程只能执行一次start方法），等待JVM的调度（此时该线程并没有运行）
  • 运行状态：线程对象获取到JVM调度，如果存在多个CPU，那么允许多个线程并行运行。
• 阻塞状态（BLOCKED）：正在运行的线程因为某种原因放弃了CPU，暂时停止运行，就会进入阻塞状态；此时JVM不会给线程分配CPU，直到线程重新进入就绪状态，才有机会转到运行状态。（阻塞两种情况：1，当A线程运行过程中，视图获取同步锁时，却被B线程获取。此时，JVM把A线程存入到对象的锁池中，A线程就进入到阻塞状态。2，当现场处于运行过程中时，发出了IO请求，此时进入阻塞状态）。
• 等待状态（Waiting等待线程只能被其他线程唤醒）：当线程使用wait()方法可以让线程进入到等待状态。JVM把当前线程存在对象等待池中。
• 计时等待状态（TIMED WAITING）：使用了带参数的wait方法和sleep方法。
• 终止状态（TERMINATED）：正常执行run方法结束后或者遇到异常而退出。

线程Join方法

线程的join方法，表示一个线程等待另一个线程完成后才执行。
例子：我们让主线程打印1-10，创建一个子线程，让他也打印1-10，当主线程打印到5的时候让创建的子线程执行所有操作后再执行自己还没有打印完的数据：

class Join extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(this.getName()+i);
        }
    }
}

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Join jo = new Join();
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+i);
            if(i==5){
                jo.start();
                jo.join();
            }
        }
    }
}

关于此程序的执行流程可以大致为：

后台线程

在后台运行的线程，其目的是为其他线程提供服务，也称为“守护线程”。JVM的垃圾回收线程就是典型的后台线程。

特点: 若所有的前台线程都死亡，后台线程自动死亡,前台线程没有结束，后台线程是不会结束的。测试线程对象是否为后台线程:使用thread.isDaemon()。前台线程创建的线程默认是前台线程，可以通过setDaenon(true)方法设置为后台线程,并且当且仅当后台线程创建的新线程时，新线程是后台线程。设置后台线程: thread.setDaemon(true)该方法必须在start方法调用前,否则会报错。

例子：创建一个后台线程打印1-100，主线程只打印1-5，看前台线程结束后，后台线程是否也结束。

class Daemon extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(this.getName()+i);
        }
    }
}
public class DaemonDemo {
    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
        Daemon da = new Daemon();
        da.setDaemon(true);
        da.start();
    }
}

运行结果：

main0
main1
main2
main3
main4
Thread-00
Thread-01
Thread-02

线程组

在Java中存在一个ThreadGroup类表示线程组，该类可以对一组线程进行集中管理。用户创建线程的时候可以通过构造器指定所属线程组Thread(ThreadGroup group, Runnable target) 。如果A线程创建B线程没有指定所属组，那么就把B线程加入到A线程组中去。一旦创线程加入到所属组后，该线程就一直存在该组中，直到死亡。