Java多线程基础

一、程序，进程，线程等相关概念的理解

1. 程序是指未完成指定任务，用某种语言编写的一段代码指令的集合，即指一段静态的代码。
2. 进程是程序的一次执行过程，可以理解为正在执行的一个程序。（进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域）
3. 进程进一步细分为线程，是程序内部的一条执行路径。（线程作为调度和执行的单位，线程之间的切换开销小）
4. 每个线程都拥有自己独立的栈和程序计数器
5. 多个线程会共享同一个进程中的方法区和堆

二、单核与多核，并行与并发的区别

1. 单核CPU是一种假的多线程，因为在同一个时间单元内，最多只能处理一个线程，只是因为时间短，感受不到
2. 多核CPU才能够真正发挥多线程的作用（现在的服务器都是多线程的）
3. 一个Java应用程序运行过程中最少包括三条线程即：main线程，gc垃圾回收线程，异常处理线程
4. 并行是指多个CPU同时处理多个任务
5. 并发是指单个CPU同时处理多个任务

三、创建多线程的两种方式

　　方式一：继承extends Thread

1. 创建一个Thread类的继承类
2. 重写该继承类中的run()方法
3. 实例化该继承类
4. 调用对象的start()方法

　　方式二：实现implements Runnable()

1. 创建一个Runnable()接口的实现类
2. 重写该实现类中的run()方法
3. 实例化该实现类并将其作为形参传进Thread类的构造器
4. 调用Thread的实例化对象的start()方法

　　二者的优劣？

　　通过实现Runnable接口的方式来实现多线程更好，原因：

1. 没有单继承的局限性
2. 更适合来处理共享数据

四、Thread类中的常用方法

1. run()-----------------------------在线程调用start()方法时，会间接调用该方法
2. start()----------------------------启动当前线程，调用run()方法
3. currentThread()---------------静态方法，返回的当前线程
4. getName()----------------------获取当前线程name属性的值
5. setName()-----------------------设置当前线程name属性的值
6. sleep()---------------------------传进一个int型的参数表示毫秒数，使得当前线程进入阻塞状态
7. yield()----------------------------释放CPU的执行权，当前有可能又接着抢到
8. stop()-----------------------------已过时，强制使当前线程死亡
9. join()------------------------------例：在当前线程a中调用其他线程b.join()，使得当前线程a进入阻塞状态，只有当线程b执行完后，才继续接着线程a的执行
10. isAlive()---------------------------判断当前线程是否死亡

五、线程的优先级

1. MAX_PRIPORITY=10
2. NORM_PRIPORITY=5(DEFAULT)
3. MIN_PRIPORITY=1

　　说明：默认的线程优先级是5，可以通过get/set方法来设置当前线程的优先级，即pripority属性。但是，优先级别越高，只是意味着该线程有更高的概率抢到CPU的执行权，并不是确切的。

六、线程通信：

 

1. wait()----------------使得该线程进入阻塞状态，并释放锁
2. notify()--------------唤醒位于阻塞状态的线程
3. nitifyAll()------------唤醒所有位于阻塞状态的线程

　　说明：这三个方法都是在Object类中定义的，必须声明在同步代码块或同步方法中，且调用者必须是这二者中的同步监视器，否则，会报IlleaalMonitorStateException异常

　　wait()与sleep()的异同

　　相同点：调用者二者方法后，线程都会进入阻塞状态

　　不同点：

• • 方法声明的位置不同，Thread类中声明sleep()。而Object类中只能使用wait()
  • sleep()不会释放同步监视器，wait()则正好相反
  • wait()必须在同步代码块或同步方法中使用，且调用者必须是该块或方法内的同步监视器

　　线程的分类：

1. 用户线程
2. 守护线程

七、线程的生命周期

• 新建

1. 当线程实例化后为调用Start()方法时

• 就绪

1. 当线程调用start()方法，当前线程就进入了就绪状态

• 运行

1. 当线程获取CPU执行权时，当前线程就进入运行状态

• 阻塞

 

　　　　运行状态-->阻塞状态

1. 1. sleep()
   2. wait()
   3. 失去锁
   4. join()
   5. suspend()

　　　　阻塞状态-->就绪状态

1. 1. sleep时间到
   2. join时间到
   3. notify() or notifyAll()
   4. 拿到锁
   5. resume()

 

• 死亡

 

1. run()方法运行结束
2. stop()
3. 出现ERROR或者EXCEPTION没处理

八、线程的同步机制

　　案例：创建多个窗口买票，初始票数为100，直至票数为零结束

　　　　出现的问题：多个线程同时买票出现重票的情况

　　　　原因：多个线程操作共享数据时，一个线程还未结束操作，另外一个线程就参与进来

　　　　解决方法：当有线程操作共享数据时，其他线程也想执行操作时，先让他们进入阻塞状态，直到操作共享数据的线程结束。

　　方法一：同步代码块

　　　　synchronized(同步监视器){

　　　　　　需要被同步的代码

　　　　}

　　　　说明：

1. 1. 同步监视器俗称锁，可以是对象，也可以是类
   2. 当使用继承来实现多线程时，慎用this来充当同步监视器，可使用类.class
   3. 当使用实现Runnable接口的方式实现多线程时，可使用This充当同步监视器

　　方法二：同步方法

　　　　若方法体内所有的代码都涉及到共享数据时，可在定义方法时，在权限修饰符后面+synchronized即可。

　　　　说明：

1. 1. 同步方法仍然涉及到同步监视器，只是无需显示声明
   2. 当当前方法是static时，同步监视器是类本身，反之，则是对象

　　方式三：Lock锁，JDK5.0中新增的

　　　　在需要被同步的代码前，写上lock(),结束时unlock()即释放锁。

　　　　与synchronized的区别：

1. 1. synchronized在代码块或方法执行完毕后会自动的释放锁
   2. Lock则需要我们手动的去释放锁

九、面试题，写一个线程安全的懒汉模式

public class Bank {
    private static Bank instance = null;
    public static Bank getInstance(){
    //多加一层判断，使得线程仅在一开始时没有生成实例时出现阻塞状态
        if(instance == null){
            synchronized (instance) {
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

十、死锁

　　不同的线程分别占用着对方需要同步的资源不放，导致所有的线程都进入了阻塞状态。当出现死锁时既不会报错，也不会出现异常，我们使用Java的同步机制时，要避免死锁的发生

　　案例：

　　

public class DeadLock {
    public static void main(String[] args) {
        B b = new B();
        A a = new A();
        a.b = b;
        b.a = a;
        // 调用A对象实例的方法一
        new Thread() {
            public void run() {
                a.A1();
            }
        }.start();
        // 调用B对象实例的方法一
        new Thread() {
            public void run() {
                b.B1();
            }
        }.start();
    }
}
class A {
    public B b;
    public synchronized void A1() {
        System.out.println("我的锁是A的实例");
        // 调用B2方法，需要b锁,但是被B1方法给握着
        try {
            Thread.currentThread().sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        b.B2();
    }
    public synchronized void A2() {
        System.out.println("我的锁是a");
    }
}
class B {
    public A a;
    public synchronized void B1() {
        System.out.println("我的锁是B的实例");
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a.A2();
    }

    // 调用A2方法，需要a锁,但是被A1方法给握着
    public synchronized void B2() {
        System.out.println("我的锁是b");
    }
}

十一、锁的释放与否

释放锁的情况：

1. 当前线程的同步代码块或同步方法执行完毕
2. 当前线程出现了未处理的异常或错误
3. 当前线程在同步代码块或同步方法中遇到了return或break等终止语句
4. wait()

不释放锁的情况：

1. sleep()、yield()等方法使得当前线程进入阻塞状态，但依然不会释放同步监视器
2. 当前线程执行同步代码块或同步方法时，其他线程调用了当前线程的suspend()方法将其挂起，该线程不会释放锁（应尽量避免使用suspend()、resume()等方法来控制线程）

十二、JDK5.0中新增的创建多线程的方式

• 通过实现Callable接口的方式来创建多线程

　　　　好处：

1. 1. 不同于前两种方式，该方法可以有返回值
   2. 支持泛型，且可以抛出异常，被外面所捕获

• 通过线程池

　　　　好处：

1. 1. 提高了响应速度，不必每次都创建新线程，降低了资源消耗
   2. 便于管理

　　　　代码展示：

　　　　　　

public class ThreadPoolTest {
    
    public static void main(String[] args) {
         ExecutorService service = Executors.newFixedThreadPool(10);
         
         System.out.println(service.getClass());//class java.util.concurrent.ThreadPoolExecutor
         
         ThreadPoolExecutor service1 =  (ThreadPoolExecutor)service;
//        设置线程池的核心参数
         service1.setCorePoolSize(10);
         
//         适用于Runnable接口的实现类
//         service.execute(null);
//        适用于Callable接口的实现类
//         service.submit(null);
        service.shutdown();
    }
}