Java基础（八）多线程

1.Java程序运行原理

* A:Java程序运行原理
    * Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
    
* B:JVM的启动是多线程的吗

    * JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

2.多线程程序实现的方式

（1）继承thread类并重写run（）方法

public class Demo_thread {
    public static void main(String[] args) {
        myThread mt = new myThread();
//        mt.run();
        mt.start();                       //使该线程开始执行，Java虚拟机调用该线程的run方法
                                          //开启线程
        for (int i = 0;i <1000;i++){
            System.out.println("bbbbbb");
        }
    }
}
class myThread extends Thread{
    public void run(){
        for (int i =0 ;i <1000;i++){
            System.out.println("aaaaaaaaa");
        }
    }
}

（2）实现Runnable接口，重写run（）方法

    * 1,看Thread类的构造函数,传递了Runnable接口的引用
    * 2,通过init()方法找到传递的target给成员变量的target赋值
    * 3,查看run方法,发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法

public class Demo_thread {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();              //创建Runnable的子类对象
        Thread t  = new Thread(mr);                    //将其当作参数传递给Thread的构造函数
        t.start();
        for (int i = 0;i <1000;i++){
            System.out.println("bbbbbb");
        }
    }
}
class MyRunnable implements Runnable{                       //定义一个类实现Runnable
    @Override
    public void run() {
        for (int i =0 ;i <1000;i++){
            System.out.println("aaaaaaaaa");
        }
    }
}

（3）两种方式的区别

* 查看源码的区别:
    * a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
   * b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
* 继承Thread
    * 好处是:可以直接使用Thread类中的方法,代码简单
    * 弊端是:如果已经有了父类,就不能用这种方法
* 实现Runnable接口
    * 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的

    * 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

3.匿名内部类实现线程的两种方式

public static void main(String[] args) {
        //Thread继承
        new Thread(){                                      //继承Thread类
            public void run(){                             //重写run方法
                for (int i =0 ;i <1000;i++){
                    System.out.println("aaaaaaaaa");
                }
            }
        }.start();                                          //开启线程


        // Runnable 接口
        new Thread(new Runnable(){
            public void run(){
                for (int i = 0;i <1000;i++){
                    System.out.println("bbbbbb");
                }
            }
        }).start();
    }

4.多线程的方法

（1）获取名字和设置名字

Thread t1 = new Thread(){
          public void run(){
              for (int i = 0;i<1000;i++){
                  System.out.println(this.getName() + "aaaaaaaaa");
              }
          }
        };

        Thread t2 = new Thread(){
            public void run(){
                for (int i = 0;i<1000;i++){
                    System.out.println(this.getName() + "bbbbbb");
                }
            }
        };

        t1.setName("xxx");
        t2.setName("yyy");

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

若不设置名字，则默认为Thread-0、Thread-1   ……

（2）获取当前线程的对象

Thread.currentThread(), 主线程也可以获取

public static void main(String[] args) {
        new Thread(){
            public void run(){
                for (int i = 0;i<1000;i++){
                    System.out.println(getName() + "aaaaaaaaa");
                }
            }
        }.start();

        new Thread(new Runnable(){
            public void run(){
                for (int i = 0;i<1000;i++){
                    System.out.println(Thread.currentThread().getName() + "bb");
                }
            }
        }).start();

        
        System.out.println(Thread.currentThread().getName());          //获取主线程的名字:main

    }

（3）休眠线程

Thread.sleep(毫秒,纳秒)

        new Thread(){
            public void run(){
                for (int i = 0;i < 10 ;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(this.getName()+"aaaaaa");
                }
            }
        }.start();
        new Thread(){
            public void run(){
                for (int i = 0 ;i<10;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(this.getName()+"bbbbbbbbb");
                }
            }
        }.start();

（4）守护线程

* setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出

（5）加入线程              需要抛出异常，插队的线程需要用final声明

* join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
* join(int), 可以等待指定的毫秒之后继续

（6）礼让线程

* yield让出cpu   Thread.yield();

（7）设置线程的优先级

* setPriority()设置线程的优先级   1-10     默认为5，最小为1，最大为10

5.同步代码块

* 1.什么情况下需要同步
    * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
    * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

* 2.同步代码块

    * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块

    * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

synchronized(d){                //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象，因为匿名对象不是 

                                               同一个对象

     要同步的代码块

  }

6.同步方法

* 非静态同步函数的锁是:this

public synchronized void print1() {

        }

public void print2() {

       synchronized(this){

        }

}

* 静态的同步函数的锁是:字节码对象

public static synchronized void print2() {}

class Printer {

public static void print1() {
                synchronized(Printer.class){

            }

    }

}

7.线程安全问题                    add方法是否有同步

* 多线程并发操作同一数据时, 就有可能出现线程安全问题

* 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作

Vector,    StringBuffer,   Hashtable,    Collections.synchroinzed(xxx)

    * Vector是线程安全的,ArrayList是线程不安全的
    * StringBuffer是线程安全的,StringBuilder是线程不安全的
    * Hashtable是线程安全的,HashMap是线程不安全的

8.死锁      哲学家问题

* 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁

9.两个线程间的通信

* 1.什么时候需要通信
    * 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
    * 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
* 2.怎么通信
    * 如果希望线程等待, 就调用wait()
    * 如果希望唤醒等待的线程, 就调用notify();

    * 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

10.三个或三个以上间的线程通信

* 多个线程通信的问题
    * notify()方法是随机唤醒一个线程
    * notifyAll()方法是唤醒所有线程
    * JDK5之前无法唤醒指定的一个线程
    * 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

11.互斥锁

* 1.同步
    * 使用ReentrantLock类的lock()和unlock()方法进行同步
* 2.通信

    * 使用ReentrantLock类的newCondition()方法可以获取Condition对象

    * 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法

    * 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了（condition 监视器）

12.线程组

* Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
* 默认情况下，所有的线程都属于主线程组。
        * public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
        * public final String getName()//通过线程组对象获取他组的名字
* 我们也可以给线程设置分组
        * 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
        * 2,创建线程对象
        * 3,Thread(ThreadGroup?group, Runnable?target, String?name)
        * 4,设置整组的优先级或者守护线程

13.线程池

* A:线程池概述
    * 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池
* B:内置线程池的使用概述
    * JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
        * public static ExecutorService newFixedThreadPool(int nThreads)
        * public static ExecutorService newSingleThreadExecutor()
        * 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
        * Future<?> submit(Runnable task)
        * <T> Future<T> submit(Callable<T> task)
    * 使用步骤：
        * 创建线程池对象
        * 创建Runnable实例
        * 提交Runnable实例
        * 关闭线程池

14.线程生命周期