Java多线程

基本概念
Java同步机制来解决线程安全的问题

基本概念

程序（program）

一段静态的代码

进程（process）

程序的一次执行过程，或者是正在运行的程序，如：运行中的QQ
程序是静态的，进程是动态的
进程是资源分配的单位

线程（thread）

进程可细分为线程，是一个程序内部的一条执行路径
若一个进程同一时间并行执行多个线程，就是支持多线程的
生命周期：新建–就绪–执行–（阻塞）–死亡

多线程（multi-thread）

优点

提高应用程序的响应，对图形化界面更有意义，增强用户体验
提高CPU的利用率
改善程序结构

应用场合

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

生成线程

通过继承：extends Thread

class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
            System.out.println(i);
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        //调用start（）方法：1⃣ 启动当前的线程 2⃣ 调用当前线程的run（）方法
        mt.start();

        //如下操作仍是在main线程中执行的
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0)
                System.out.println(i + "******  main()    ********");
        }

    }
}

通过接口：implements Runnable

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 ThreadTest2 {
    public static void main(String[] args) {
        MThread mThread = new MThread();
        Thread t1 = new Thread(mThread);
        t1.start();

        Thread t2 = new Thread(mThread);
        t2.start();
    }
}

说明：

在开发中，优先选择实现接口的方式来创建线程。因为实现的方式没有类的单继承性的局限性；实现的方式更适合来处理多个线程有共享数据的情况。
两种方式的关系：public class Thread implements Runnable{ }
相同点：都需要重写run()

Java同步机制来解决线程安全的问题

死锁

理解：

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
使用同步时，避免出现死锁

同步机制

同步代码块

synchronized (同步监视器){
  //需要被同步的代码
}

说明：

操作共享数据的代码，即为需要同步的代码
共享数据：多个线程共同操作的变量
同步监视器：锁。任何一个类的对象，都可以充当锁，但是多个线程必须要共用同一把锁

package Thread;

//synchronized(同步监视器){
//      需要被同步的代码
//}

class Window3 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while(true){
            //this也可以作为对象
            synchronized(obj){
                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

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

    }
}

同步方法

public synchronized void show(){
  // 需要被同步的代码
}

说明：

同步方法仍然涉及到同步监视器，只是不需要显式的声明
非static的同步方法，同步监视器为this
static的同步方法，同步监视器为当前类本身

Lock（JDK5.0增加）

实现ReentrantLock类，调用lock()和unlock()

synchronized和Lock的异同点

相同点：二者都可以解决线程安全的问题

不同点：

synchronized机制在执行完相应的同步代码后，自动释放同步监视器
Lock需要手动地启动同步lock()，同时结束同步也需要手动实现unlock()

package Thread;

//解决线程安全问题方式三：Lock

import java.util.concurrent.locks.ReentrantLock;

class WindowLock implements Runnable{
    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();
            }

        }
    }
}

public class LockTest1 {
    public static void main(String[] args) {
        WindowLock wl = new WindowLock();

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

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

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

优先使用的顺序：

Lock–同步代码块–同步方法

线程通信

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

涉及到的方法：wait() & notify() & notifyAll()

wait（）：一旦执行此方法，当前线程就会进入阻塞状态并释放同步监视器
notify（）：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就会唤醒优先级高的
notifyAll（）：一旦执行此方法，就会唤醒所有被wait的线程

说明：

wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中
wait（），notify（），notifyAll（）三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalManitorStateException
wait（），notify（），notifyAll（）三个方法都定义在java.lang.Object类中

sleep() & wait()

相同点：一旦执行方法，都可以使当前的线程进入阻塞状态

不同点：

声明的位置不同，Thread类声明sleep（），Object类声明wait（）
调用范围不同，sleep（）可以在任何需要的场景下调用，wait（）必须在同步代码块或同步方法中
sleep（）不释放同步监视器，wait（）释放同步监视器

创建线程的其他方式

实现Callable接口（JDK5增加）

如何理解Callable接口比Runnable接口强大？

call（）可以有返回值
call（）可以抛出异常，被外面的操作捕获，获取异常信息
Callable是支持范型的

线程池

思路：

提前创建好多个线程放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁地创建销毁，实现重复利用

优点：

提高响应速度（减少创建新线程的时间）
降低资源消耗
便于线程管理

一些参数： corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：最多保持时间

创建线程的4种方式，通信安全