Java笔记(9)-多线程

1. 线程的调用

1. 分时调用：
    所有线程轮流使用CPU
2. 抢占式调用：
    设置线程的优先级，优先级高的抢占的CPU的几率大。

2. Thread类

1. Java程序中main方法为主线程
2. 创建多程序程序方式 -- 创建Thread类对象
    a. Thread类是描述线程的类，我们要实现多线程程序，就必须继承Thread类
    b. 实现步骤：
        1. 创建一个类继承Thread类
        2. 重写Thread类中的run方法，设置线程任务(即该类对象开启线程任务后做什么)
        3. 创建定义的子类对象
        4. 调用Thread类中的start方法，开启新的线程执行run方法
            void start();//使该线程开始执行，Java虚拟机会调用该线程run方法
3. 注意事项：
    a. 多次启动一个线程是非法的。特别是当线程结束后，不能再重新启动
    b. java程序是抢占式调用，哪个线程优先级高，哪个线程优先执行；同一优先级随机选择执行
4. 创建多线程程序方式 -- 创建Runnable接口实现类
    a. Runnable接口应该由那些打算通过某一线程执行其实例的类来事项。该类必须定义一个run的无参方法
    b. 在Thread的构造方法中，含有Runnable对象的构造方法
        Thread(Runnable target) -- 分配新的Thread对象
        Thread(Runnable target, String name) -- 分配新的Thread对象，并设置名称
    c. 实现步骤
        1. 创建Runnable接口的实现类
        2. 重现Runnable接口中的run方法
        3. 通过带有Runnable实现类的Thread带参构造创建一个Thread对象
        4. 调用Thread中的start方法
5. 实现Runnable接口创建多线程的好处：
    a. 避免了单继承的局限性
        1. 一个类只能继承一个类，继承了Thread就不能继承自其他类
        2. 实现了Runnable接口，还可以继承其他类，实现其他接口
    b. 增强了程序的扩展性，降低了程序的耦合性
        1. 实现Runnable接口的方式，将设置线程任务和开启新线程进行分离
            在实现类中重写run方法，设置线程任务
            创建Thread类对象，调用start方法开启新线程

3. Thread类的start方法会开辟一个新的栈空间，用来执行run方法。多个线程之间互不影响
4. Thread类常用方法

1. String getName():
    返回该线程的名称
2. static Thread currentThread():
    返回当前执行的线程对象的引用
    主线程名称：main；创建名称：Thread-0，Thread-1，...
3. setName(String name):
    改变线程名字
    或者使用带参数的构造方法，创建时设置线程名称
4. sleep(long millis):
    是当前执行的线程以指定毫秒数暂停执行

5. 匿名内部类实现线程的创建

1. 简化继承父类，创建父类方法，创建子类对象一步完成
2. 格式：
    new 父类/接口() {
        //重写父类/接口的方法
    }
3. 例如：
    new Thread() {
        public void run(){
            for(int i = 0;i<10;i++)
            {
                sout(i);
            }
        }
    }.start();
    //或者接口实现类
    new Thread(new Runnable(){
        public void run(){
            for(int i = 0;i<10;i++)
            {
                sout(i);
            }
        }
    }).start();

6. 线程同步机制

1. 同步代码块
    a. 格式：
        synchronized(锁对象){
            //可能会出现线程安全的代码块(访问共享资源的代码)
        }
    b. 使用方式：
        1. 创建一个锁对象
            Object obj = new Object();
        2. 线程不安全代码放入同步代码块中
            synchronized(obj){
                访问了共享资源的代码块
            }
    c. 注意事项：
        1. 通过代码块中的锁对象，可以使用任意对象
        2. 但是必须保证多个线程使用的锁对象是同一个
        3. 锁对象作用：将同步代码块锁住，只让一个线程在同步代码块中执行
2. 同步方法：
    a. 格式：
        修饰符 synchronized 返回值类型 方法名(参数列表){
            //访问共享资源的代码块
        }
    b. 使用步骤：
        1. 将访问量共享资源的方法抽取出来放到一个方法中
        2. 给该方法添加synchronized修饰符
    c. 非static同步方法的锁对象其实就是线程的实现类对象
    d. static同步方法的锁对象是本类的class的属性-->class文件对象(反射)
3. 锁操作
    a. Lock接口实现提供了广泛的锁定操作
    b. 常用方法：
        void lock();获取锁
        void unlock();释放锁
    c. 使用步骤
        1. 在成员位置创建一个ReentrantLock对象
        2. 在操作共享资源的代码前使用lock方法获取锁
        3. 在操作共享资源的代码结束时使用unlock方法释放锁
    d. 与try/catch/finally结合使用
        ReentrantLock l = new ReentrantLock();
        l.lock();
        try{
            //操作共享资源代码
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            l.unlock();//将解锁操作放在finall中，无论程序是否异常，都会释放锁
        }

7. 线程的状态

1. NEW：新建状态
    new Thread();
2. BLOCKED：阻塞状态
    未抢到CPU
3. RUNABLE：运行状态
    抢到CPU
4. TIME_WAITING：休眠状态
    由sleep(long)或者wait(long)方法使得从RUNABLE状态转到TIME_WAITING状态
5. WAITING：无限等待状态
    由对象调用无参数的wait()方法使得从RUNABLE状态转到WAITING状态
    只有对象调用notify()方法时，才能唤醒
6. TERMINATED：终态
    线程死亡

8. 线程池：避免频繁创建线程的开销浪费

1. 线程池可以看作是一个容器，里面放线程对象。
    a. 程序第一次启动时，创建多个线程，保存到一个集合
    b. 当需要使用线程时，可以从线程中取出一个线程 
        -- 使用remove，返回被删除的线程
        -- 因为一个线程只能被使用一次
    c. 当使用完成线程后，归还给线程池
2. 线程池：JDK 1.5+
    a. java.util.concurrent.Executors：创建线程池的工厂类，用来生成线程池
    b. 成员函数：
        static ExecutorService newFixedThread(int nThreads);//创建一个指定数量的线程池
    c. 使用步骤：
        1. 使用线程池的工厂类对象
        2. 创建一个类，实现Runnable接口，重写run方法，设置线程任务
        3. 调用ExecutorService中的方法submit，传递线程任务(实现类)，开启线程执行run方法
        4. 调用shutdown销毁线程池