java多线程初步认识到更深的理解

一、基本概念：程序、进程、线程

程序

程序（Program）：是完成特点任务、用某种语言编写的一组指令的集合。即值一段静态的代码，静态的对象。是对数据描述与操作的代码的集合，是应用程序执行的脚本。

进程:

进程（process）是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
如：运行的QQ、运行中的MP3播放器
进程是程序执行的一次过程。程序是静态的，进程动态的。运行一个程序即是一个进程从创建、运行到消亡的过程。

线程

线程（thread）的定义：进程可进一步细化为线程，是一个程序内部的一条执行路径。
1、若执行一个进程同一时间并行执行多个线程，就是支持多线程的。
2、线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（PC），线程切换的开销小。
3、一个进程中的多个线程共享相同的内存单元、内存地址空间→他们从同一堆中分配对象，可以访问相同的变量和对象。这就是使得线程间通信更简便、高效。但多线程操作共享的系统资源可能会带来安全的隐患。

编程离不开生活，可以想象我们生活中的“多线程”事物，更好理解及学习后续的概率。

基本知识

1、计算机的多核发展是程序多线程发展的基石，才能更好的发挥多线程得效率。
2、一个java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
3、并行和并发：
并行：多个CPU同时指向多个任务、比如：多个人同时做不同的事。
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个人做同一件事。

优点

1、提高应用程序的响应。对图形化界面更有意义，可以增强用户体验；
2、提高计算机系统CPU的利用率；
3、改善程序结构。将即长又复杂的进程分为多个线程，独立运行，利于理解和修改。

二、线程的创建和使用

（一）继承于Thread类

①创建一个类继承Thread类的子类
②重写Thread类的run()–>将此线程执行的操作生命在run()中
③创建Thread类的子类的对象
④通过此对象调用start()
例子：遍历100以内的所有的偶数

/**
 * 1.继承于Thread类
 * ①创建一个类继承Thread类的子类
 * ②重写Thread类的run()
 * ③创建Thread类的子类的对象
 * ④通过此对象调用start()
 * 例子：遍历100以内的所有的偶数
 */
//创建子类
class MyThread extends Thread{
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //创建自定义类对象
        MyThread myThread = new MyThread();
        //调用start()方法；①启动当前线程，②调用当前线程run()
        myThread.start();
//        myThread.run();//类似于调用一个方法
//        MyThread myThread1 = new MyThread();
//        myThread1.start();
        //如下操作仍然是在main线程中执行得。
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println("********主线程"+i);
            }
        }
    }
}

1.1练习：创建两个线程，其中一个线程遍历100的偶数，另一个遍历100以内的奇数。

public class ThreadDemo1 {
    public static void main(String[] args) {
//        MyThread1 t1 = new MyThread1();
//        MyThread2 t2 = new MyThread2();
//        t1.start();
//        t2.start();
        //创建Thread类的匿名子类的方式
        new Thread(){
            @Override
            public void run() {
                //遍历奇数
                for (int i = 0; i < 100; i++) {
                    if(i % 2 == 0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                //遍历奇数
                for (int i = 0; i < 100; i++) {
                    if(i % 2 != 0){
                        System.out.println(Thread.currentThread().getName()+":"+i);
                    }
                }
            }
        }.start();
    }

}
class MyThread1 extends Thread{
    @Override
    public void run() {
        //遍历偶数
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

1.2 Thread类中常用方法

1、start():启动当前线程；调用当前线程的run();
2、run():通常需要重新Thread类中的次方法，将创建的线程要执行的操作声明在此方法中
3、currentThread():静态方法，返回当前执行代码的线程
4、getName():获取当前线程的名字
5、setName():设置当前线程的名字
6、yield():释放当前CPU的执行权
7、join():在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
8、stop():已过时。当执行此方法时，强制结束当前线程
9、sleep(Long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程阻塞状态。
10、isAlive():判断当前线程是否还存活

1.3线程的调度

java的调度方式：
①同优先级线程组成先进先出队列（先到先服务），使用时间片策略；
②对高优先级，使用优先调度的抢占式策略；
线程的优先级
①MAX_PRIORITY:10
②MIN_PRIORITY:1
③NORM_PRIORITY:5
涉及的方法
getPriority():放回线程优先级值
setPriority(int newPriority):设置线程的优先级
说明
①线程创建时继承父线程的优先级
②低优先级知识获得调度的概率低，并非一定是在高优先级线程之后才被调用。高优先级的线程抢占线程CPU的执行权，但是只是从概率上来说比较高。

public class PriorityDemo {
    public static void main(String[] args) {
        PriorityThread demo = new PriorityThread();
        //设置分线程的优先级
        demo.setPriority(Thread.MAX_PRIORITY);
        demo.start();
        //遍历偶数
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            }
        }
    }
}

class PriorityThread extends  Thread{
    @Override
    public void run() {
        //遍历偶数
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
            }
        }
    }
}

4.例子：创建3个窗口，总票数为100张

/**
 * 例子：创建三个窗口买票，总票数为100张
 * 存在线程安全问题，待解决
 */

class Window extends Thread{
    private static int ticket = 100;//票的总张数

    @Override
    public void run() {
        while (true){
            if(ticket>0){
                System.out.println(getName()+":卖票，票号为："+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();
        
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

（二）实现Runnable接口

①创建一个实现Runnable接口的类
②实现类去实现Runnable中的抽象方法：run()
③创建实现类的对象
④将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
⑤通过Thread类的对象调用start()

/**
 * 创建多线程的方式二：实现Runnable接口
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        MThread mThread = new MThread();//创建实现了Runnable接口的对象
        Thread t = new Thread(mThread);//根据对象创建线程对象
        t.start();//启动线程  调用了Runnable类型的target
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);//根据对象创建线程对象
        t2.start();
    }
}

class MThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

卖票小线程修改

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window1 implements Runnable{
    private int ticket = 100;//票的总张数

    @Override
    public void run() {
        while (true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

（三）比较两种创建线程的方式

开发中：优先选择实现Runnable接口的方式
原因：①实现的方式没有类的单继承性的局限性
②实现的方式更适合来处理多个线程共享数据的情况
联系：Thread类本身实现Runnable
相同点：两种方式都需要重新run()，将线程要执行的逻辑声明在run()中。

三、线程的生命周期

新建：当一个Thread类或者其子类的对象被声明并创建时，新生的线程对象出于新建状态
就绪：出于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，知识没有分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被认为挂起或者执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

四、线程的同步

火车票问题例子引出问题：
1.问题：买票过程中，出现了重票、错票–>出现了线程的安全问题
2.问题出现的原因：当某个线程操作车票操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.如果解决：当一个线程a在操作ticket的时候，其他线程不能参与进来，知道线程a操作完，其他线程才能操作ticket。
4.在java中，我们通过同步机制，来解决线程的安全问题。

方式一、同步代码块

synchronized(同步监视器){
//需要被同步的代码，不要包多了也不要包少了。
}
说明：
1.操作共享数据的代码，即为需要被同步的代码；
2.共享数据：多个线程共同操作的变量。比如ticket就是共享数据；
3.同步监视器，俗称：锁；任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用一把锁。
在实现Runnable接口创建多线程的方式中，我们可以考虑使用this作为同步锁。在继承的方式中我们要慎用this。

public class WindowImpl {
    public static void main(String[] args) {
        Window2 w = new Window2();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{
    private int ticket = 100;//票的总张数
    Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized(obj){
//            synchronized(this){//此时的this:唯一的windows1的对象。在“实现”中不不能这样
//                synchronized(Window2.class){//类的对象，反射知识。Window2.class只加载一次
                if(ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
关于同步方法的总结：
①同步方法仍然涉及到同步监视器，只是不需要我们现实的声明；
②非静态的同步方法，同步监视器是：this;
静态的同步方法，同步监视器是：当前类本身。

5.在使用同步监视器解决了线程的安全问题—>好处

6.线程的死锁问题
死锁
①不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
②出现死锁后，不会出现异常，不会出现提示，知识所有的线程都出于阻塞状态，无法继续。
解决方法：
①专门的算法、原则；
②尽量减少同步资源的定义
③尽量避免嵌套同步。

方式三：Lock(锁)

①从JDK5.0开始，Java提供了更强大的线程同步机制----通过显示定义同步锁对象来实现同步。同步锁Lock对象充当。
②Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
③ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。
④synchronized和Lock的异同
相同：解决线程安全
不同：synchronized机制在执行完相应的同步代码块以后，自动的释放同步监视器
Lock需要手动的启动同步(lock())，同时结束同步也需要手动的实现(unlock())

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：LocK锁   JDK5.0新增
 *
 */
public class LockTest {
    public static void main(String[] args) {
        LockDemo l = new LockDemo();

        Thread t1 = new Thread(l);
        Thread t2 = new Thread(l);
        Thread t3 = new Thread(l);

        t1.start();
        t2.start();
        t3.start();
    }
}

class LockDemo implements Runnable{
    private int ticket = 100;
    //1.实例化
    private ReentrantLock reentrantLock = new ReentrantLock();

    @Override
    public void run() {

        while (true){
            try{
            reentrantLock.lock();
            if(ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":售票，票号为"+ticket);
                ticket--;
            }else {
                break;
            }
        }finally {
                reentrantLock.unlock();
            }
        }
    }
}

五、线程通信

例题：使用两个线程打印1-100，线程1，线程2交替打印；

package com.sgh.threadfile.java1;

public class CommunicationTest {
    public static void main(String[] args) {
        Number num = new Number();
        Thread t1 = new Thread(num);
        Thread t2 = new Thread(num);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

class Number implements Runnable {
    private int number = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (number <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        wait();//使得调用如下wait()方法的线程阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

涉及的三个方法：

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的那一个。
notifyAll():一旦执行此方法，就会唤醒所以的被wait()的线程。
说明：此三个方法必须使用在同步代码块或同步方法中。
此三个方法的调用者必须是同步方法中的同步监视器，否则会报异常。
此三个方法定义在Object类中。
面试题：sleep和wait方法的异同？
1.相同点：一旦执行方法，都可以使得当前线程进入阻塞状态
2.不同点：①两个方法声明的位置不同：Thread类中声明sleep,Object类中声明wait()；
②调用的要求不同：sleep可以在任何需要场景下调用，wait必须使用在同步代码块中；
③关于是否释放同步监视器：两个方法都使用在同步代码块或同步方法中，sleep不会释放锁，wait会释放锁。

经典例题：生产者、消费者问题

生产者（Productor）将产品交给店员（Clerk），而消费者（Customer）从店员处取走产品，店员一次只能持有固定数量的产品（比如：20），如果生产者试图生产更多的产品，店员会叫生产者停止生产，如果店中有空位放产品再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品再通知消费者来取走产品。
分析：
1.是否是多线程问题？是，生产者线程，消费者线程
2.是否有共享数据？是，店员（或者产品）
3.如何解决线程的安全问题？同步机制，有三种方法
4.是否涉及线程的通信？是

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer producer1 = new Producer(clerk);
        producer1.setName("生产者");

        Consumer consumer = new Consumer(clerk);
        consumer.setName("消费者");

        producer1.start();
        consumer.start();

    }
}
class Clerk{
    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第"+ productCount +"产品");
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumerProduct() {
        if (productCount >0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"产品");
            productCount--;
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{//生产者
    private Clerk clerk;
    public Producer (Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始生产产品......");
        while (true){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}


class Consumer extends Thread{//消费者
    private Clerk clerk;
    public Consumer (Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始生产产品......");
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumerProduct();
        }
    }
}

六、JDK5.0新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比，Callable功能更强大些
①相比run()方法，可以有返回值；
②方法可以抛出异常
③支持泛型的返回值
④需要借助FutureTask类，比如获取返回结果
Future接口：
①可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等；
②FutrueTask是Futrue接口的唯一的实现类；
③FutrueTask同时实现了Runnable,Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

public class ThreadNew {
    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()
        new Thread(futureTask).start();
        try {
            //6.获取call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法,将此线程需要执行的操作写到方法里
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum +=i;
            }
        }
        return sum;
    }
}

新增方式二、使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放在线程池中，使用时直接获取，使用完放回池中。可以避免平凡创建销毁、实现重复利用。类似生活中的公共交通工具；
优点：
①提高响应速度（减少了创建新线程的时间）
②降低资源消耗（重复利用线程池中线程，不需要每次都创建）
③便于线程管理：
corePoolSize：核心池的大小
MaxmumPoolSize：最大线程数
JDK5.0起提供了线程池相关API:ExecutorService和Executors

package com.sgh.threadfile.java2;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ThreadPool {
    public static void main(String[] args) {
        //创建指定数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor)executorService;
        System.out.println(executorService.getClass());
        //优点三
        threadPoolExecutor.setCorePoolSize(15);
        executorService.execute(new NumThread1());//适合使用Runnable
        executorService.execute(new NumThread1());//适合使用Runnable
//        executorService.submit();//适合使用与Callable
        //关闭线程池
        executorService.shutdown();
    }
}

class NumThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":"+i);
            }
        }
    }
}

总结：创建方式3、4的方法还不够熟练，但在实际开发中第四种偏多。还得多项目实战才更有趣。