1、线程学习笔记

一、概念

1、程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
2、进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
》如：运行中的QQ，运行中的MP3播放器;
》程序是静态的，进程是动态的;
》进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域;
3、线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行径。
》若一个进程同一时间并行执行多个线程，就是支持多线程的;
》线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 ;
》一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

每个进程有自己的方法区和堆，每个线程有自己的栈和程序计数器，每个线程共享进程中的方法区和堆。

4、单核CPU和多核CPU的理解

》单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。

》如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
》 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

4、并行与并发

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

5、使用多线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
多线程程序的优点：
1、提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2、提高计算机系统CPU的利用率
3、改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

6、何时需要多线程

1、程序需要同时执行两个或多个任务。
2、程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
3、需要一些后台运行的程序时。

二、创建多线程的方式

1、继承Thread类

(1)创建一个子类继承Tread类
(2)重写父类Thread类的run方法(线程要进行的操作写在run方法中)
(3)创建子类对象
(4)调用run方法

//创建一个子类继承Tread类
class MyThread extends Thread {
    //重写父类Thread类的run方法(线程要进行的操作写在run方法中)
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}
public class MyTest {
    public static void main(String[] args) {
        //创建子类对象
        MyThread my=new MyThread();
        //调用run方法
        my.start();
    }
}

问题1：是否可以使用my.run启动线程？
不可以。
问题2：如何添加新的线程？
不可以使用已经已经启动过的线程再次调用start（）方法创建线程，否则会抛IllegalThreadStateException。
再次创建另一个子类调用start()方法启动线程。

练习：创建两个线程，一个线程输出100以内的奇数，一个线程输出一百以内的偶数。(创建两个Tread子类或使用匿名子类)

  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();

2、实现Runable接口

(1)创建一个类实现Runnable接口
(2)重写Runnable接口中的run方法
(3)创建该类对象
(4)将该类对象作为构造参数创建Thread对象
(5)Thread对象调用start()方法启动线程

public class MyRun {
    public static void main(String[] args) {
            //创建该类对象
        MyRunable my=new MyRunable();
        //将该类对象作为构造参数创建Thread对象
        Thread t1 = new Thread(my);
        t1.setName("线程1");
        t1.start();
        //再创建一个线程做同样的事情
        Thread t2 = new Thread(my);
        t2.setName("线程2");
        //Thread对象调用start()方法启动线程
        t2.start();
    }
}
//创建一个类实现Runnable接口
class MyRunable implements Runnable{
//重写Runnable接口中的run方法
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if(i%2==0){         System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

比较继承Thread和实现Runnable接口两种方式。
开发中：优先选择：实现Runnable接口的方式
原因：1. 实现的方式没有类的单继承性的局限性
     2. 实现的方式更适合来处理多个线程有共享数据的情况。
联系：public class Thread implements Runnable Thread也实现了Runnable接口；
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

3、实现callable接口创建线程

1、与使用Runnable相比，Callable功能更强大些
》相比run()方法，可以有返回值
》方法可以抛出异常
》支持泛型的返回值
》需要借助FutureTask类，比如获取返回结果
2、Future接口
》可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
》FutrueTask是Futrue接口的唯一的实现类
》FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
3、创建步骤
（1）创建一个类Callable接口
（2）创建该类的对象
（3）将该类对象作为构造参数创建FutureTask对象
（4）将FutureTask对象作为构造参数创建Thread对象
（5）调用start()方法启动线程
（6）返回值取值利用FutureTask对象调用get()方法
4、如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
1. call()可以有返回值的。
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
3. Callable是支持泛型的
5、代码实现
public class threadcal {
    public static void main(String[] args) {
        //（2）创建该类的对象
        CallThread callThread = new CallThread();
        //（3）将该类对象作为构造参数创建FutureTask对象
        FutureTask futureTask = new FutureTask(callThread);
        //（4）将FutureTask对象作为构造参数创建Thread对象
        Thread thread = new Thread(futureTask);
        thread.setName("线程1");
        //（5）调用start()方法启动线程
        thread.start();
        //（6）返回值取值利用FutureTask对象调用get()方法
        try {
            int result = (int)futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//（1）创建一个类实现Callable接口
class CallThread implements Callable {
    @Override
    public Object call() throws Exception {
        int result=0;
        for(int i=0;i<=100;i++){
            if(i%2==0){
           System.out.println(Thread.currentThread().getName()+":"+i);
            }
            result+=i;
        }
        return result;
    }
}

4、线程池创建线程

1、简介
》背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
》思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
》好处：
》提高响应速度（减少了创建新线程的时间）
》降低资源消耗（重复利用线程池中线程，不需要每次都创建）
》便于线程管理
》corePoolSize：核心池的大小
》maximumPoolSize：最大线程数
》keepAliveTime：线程没有任务时最多保持多长时间后会终止
》…
2、ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
》void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
》<T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
》void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
》Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
》Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
》Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
》Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
3、创建步骤
1、创建一个实现Runnable接口或Callable接口的线程类
2、创建指定线程数量的线程池(ExecutorService)
3、设置线程池的属性需将ExecutorService的子类强转为ThreadPoolExecutor，方可调用setCorePoolSize()，setKeepAliveTime()d等方法
4、将线程类对象作为ExecutorService的execute()方法参数调用
5、关闭线程池
4、线程池的好处：
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
      corePoolSize：核心池的大小
      maximumPoolSize：最大线程数
      keepAliveTime：线程没有任务时最多保持多长时间后会终止
5、代码实现
//1、创建一个实现Runnable接口或Callable接口的线程类
class NumberThread1 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 ThreadPool {
    public static void main(String[] args) {
        //2. 提供指定线程数量的线程池
     ExecutorService service = Executors.newFixedThreadPool(10);
     ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //3.设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
//4.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
//        service.submit(Callable callable);//适合使用于Callable
        //5.关闭连接池
        service.shutdown();
    }
}

三、线程的常用方法

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

四、设置线程优先级

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5  -->默认优先级
2.如何获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下
被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

Thread.currentThread().getPriority();                   Thread.currentThread().setPriority(Thread.MAX_PRIORITY);       
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);       
Thread.currentThread().setPriority(Thread.NORM_PRIORITY);

五、案例===》卖票

共享数据：票数

Thread方式：将票数声明为静态变量private static int ticket=100；

实现Runnable方式：票数不需要声明为静态变量

六、线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程。

》它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

》守护线程是用来服务用户线程的，通过在start()方法前调用

thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

》Java垃圾回收就是一个典型的守护线程。

》若JVM中都是守护线程，当前JVM将退出。

七、线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类

及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五

种状态：

》新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

》就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

》运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能

》阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

》死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

八、线程的安全及解决

案例1：

案例2：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式

1、问题：卖票过程中，出现了重票、错票 —>出现了线程的安全问题
2、问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3、如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

解决线程安全的方法

同步的方式，解决了线程的安全问题。---好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

(1)同步代码块

同步代码块解决实现Runnable接口出现的线程安全

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

 private int ticket = 100;
    Object obj=new Object();
    @Override
    public void run() {
        //同步监视器可利用this替代，但是this必须唯一
        synchronized (obj) {
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":正在出售第" + ticket + "张票");
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }

同步代码块解决继承Thread类出现的线程安全

private static int ticket = 100;
//需将对象定义为静态的供三个对象公用
private static Object obj=new Object();
    @Override
    public void run() {
        //此时this分别进来的三个线程对象
        //可利用当前类.class充当唯一锁MyThread.class
        synchronized (obj) {
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":正在出售第" + ticket + "张票");
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }

(2)同步方法

同步方法解决实现Runnable接口出现的线程安全

 private int ticket = 100;
    Object obj=new Object();
    @Override
    public void run() {
        synchronized (obj) {
            while (true) {
               show();
            }
        }
    }
    private synchronized void show(){//此时的锁为this
        if (ticket > 0) {
           System.out.println(Thread.currentThread().getName() + ":正在出售第" + ticket + "张票");
            ticket--;
        }
    }

同步代码块解决继承Thread类出现的线程安全

静态方法的的锁为当前类本身MyThread.class

 @Override
    public void run() {
        while (true) {
            show();
        }
    }
private static synchronized void show(){//同步监视Window4.class
//private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }

(3)lock锁

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

》java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

》ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

 private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                //2.调用锁定方法lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }                   System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }

九、单例模式懒汉式改进

class Bank{
    private Bank(){}
    private static Bank INSTANCE=null;
    //此时this为Bank.class
    private static synchronized Bank getInstance(){
       if (INSTANCE==null){
           INSTANCE=new Bank();
       }
       return INSTANCE;
    }
}

class Bank{
    private Bank(){}
    private static Bank instance = null;
    public static Bank getInstance(){
        //方式一：效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if(instance == null){
            synchronized (Bank.class) {
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

1. 面试题：synchronized 与 Lock的异同？
相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现unlock()
2.优先使用顺序：
Lock——》同步代码块（已经进入了方法体，分配了相应资源）——》同步方法（在方法体之外）

十、死锁的问题

死锁

》不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

解决方法

》专门的算法、原则

》尽量减少同步资源的定义

》尽量避免嵌套同步

         StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }

十一、练习题

银行有一个账户。 有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打 印账户余额。 问题：该程序是否有安全问题，如果有，如何解决？ 
【提示】
1，明确哪些代码是多线程运行代码，须写入run()方法 。
2，明确什么是共享数据。 
3，明确多线程运行代码中哪些语句是操作共享数据的。

十二、线程的通信

1、简介
wait() 与 notify() 和 notifyAll() 
》 wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当 前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有 权后才能继续执行。
》notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待 
》notifyAll ()：唤醒正在排队等待资源的所有线程结束等待. 
》这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。 
》因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁， 因此这三个方法只能在Object类中声明。
2、wait方法
》在当前线程中调用方法： 对象名.wait() 
》使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify  (或notifyAll) 为止
》调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁） 调用此方法后，当前线程将释放对象监控权 ，然后进入等待 
》在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
3、notify()/notifyAll()
》在当前线程中调用方法： 对象名.notify() 
》功能：唤醒等待该对象监控权的一个/所有线程。 
》调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
4、经典例题：生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处 取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通 知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如 果店中有产品了再通知消费者来取走产品。 
这里可能出现两个问题： 
》生产者比消费者快时，消费者会漏掉一些数据没有取到。 
》消费者比生产者快时，消费者会取相同的数据。

5、练习2：银行取钱的问题 
1.定义一个Account类 
1）该Account类封装了账户编号（String）和余额（double）两个属性 
2）设置相应属性的getter和setter方法 
3）提供无参和有两个参数的构造器 
4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写 2.提供两个取钱的线程类：小明、小明’s wife 
1）提供了Account类的account属性和double类的取款额的属性 
2）提供带线程名的构造器 
3）run()方法中提供取钱的操作 
3.在主类中创建线程进行测试。考虑线程安全问题。