Java 多线程

一. 基本名词概念

1. 进程：一个运行的程序

2. 线程：是进程中的单个顺序控制流，是一条执行路径

（1）单线程：一个进程只有一条执行路径（记事本中的点开设置）

（2）多线程：一个进程有多条执行路径（扫雷中的计时器和游戏）

二. Java实现多线程

1. 继承Thread类的方式实现多线程

（1）定义类MyThread继承Thread类

（2）在MyThread中重写run()方法

（3）创建MyThread对象，启动线程

2. 设置和获取线程名称

（1）如果不设置线程名称默认名为"Thread-0, Thread-1..."

（2）setName("xx")设置名称，getName()获取名称

（3）设置名称也可以重写构造函数，调用父类Thread的带参构造函数，传入name

（4）获取当前正在执行的线程对象的引用：静态方法Thread.currentThread()

public class MyThread extends Thread{
    public MyThread() {
        super();
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {//快捷键Ctrl+O
        for(int i=0;i<1000;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1=new MyThread("hh1");
        MyThread my2=new MyThread("hh2");
        //run()封装线程执行的代码
        //my1.setName("Hello1");
        //my2.setName("Hello2");
        my1.start();//启动线程，由JVM调用run()方法
        my2.start();
        System.out.println(Thread.currentThread().getName());
    }
}

3. 线程调度

线程调度有两种模型：

• 分时调度模型：所有线程轮流使用CPU，平均分配每个线程占用CPU的时间片

• 抢占式调度模型：优先让优先级高的线程使用CPU，如果优先级相同则随机选择一个

Java使用的是抢占式调度模型

Thread类中提供的方法：

public final void setPriority(int newPriority)//更改此线程的优先级
public final int getPriority()//返回此线程的优先级。

MIN_PRIORITY=1
MAX_PRIORITY=10
NORM_PRIORITY=5//默认

4. 线程控制

public static void sleep(long millis)//当前正在执行的线程休眠（暂停执行）为指定的毫秒数
public final void join()//等待这个线程死亡，等价于join(0)
public final void setDaemon(boolean on)//标志着该线程是守护线程，如果运行的线程都只剩下守护线程是，Java虚拟机退出
//Java中除了用户进程就是守护进程，守护进程是后台服务进程，比如垃圾回收进程

5. 线程生命周期

6. 实现Runnable接口的方式实现多线程

（1）定义一个类MyRunnable实现Runnable接口

（2）在Runnable类中重写run()方法

（3）创建MyRunnable对象

（4）创建Thread类的对象，把MyRunnable对象作为构造方法的参数

（5）启动线程

好处：

• 避免了Java单继承的局限性，MyRunnable可以再继承其他父类

• 适合多个相同的程序的代码去处理同一个资源的情况，较好的体现面向对象思想

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);//不能直接getName()
        }
    }
}

public class MyRunnableDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();
        Thread t1=new Thread(my);
        Thread t2=new Thread(my,"hh");//带设置名的构造函数
        t1.start();
        t2.start();
    }
}

三. 线程同步

1. 卖票案例

电影院出售1000张票，三个窗口同时卖票，每次出票时间10ms

非同步出现的问题：

• 相同的票出现了多次（三个线程都打印"第100张票正在出售"）

• 出现了负数的票

问题原因：

• 线程执行的随机性导致的

2. 安全问题的解决

解决方式：把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

（1）同步代码块：

synchronized (任意对象){
　　多条语句操作共享数据的代码
}

synchronized相当于给代码加锁，任意对象就可以看成一把锁

同步的好处和弊端：

• 好处：解决了多线程的数据安全问题

• 弊端：线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中降低了程序运行效率

public class SellTicket implements Runnable{
    private int ticket=1000;
    private Object obj=new Object();//三个线程要用同一把锁，所以放一个obj变量在这
    @Override
    public void run() {
        while(true){
            synchronized (obj){//同步代码块
                //t1进来后，就会把这段代码锁起来
                if(ticket>0){
                    try {
                        Thread.sleep(10);//快捷键Ctrl+Alt+T
                        //即使t1在休息，t2抢到CPU执行权，也无法执行这段代码
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();
        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

（2）同步方法：

同步方法：就是把synchronized关键字加到方法上

修饰符 synchronized 返回值类型 方法名(参数){}

同步方法的锁对象：this

同步静态方法：就是把synchronized关键字加到静态方法上

修饰符 static synchronized 返回值类型 方法名(参数){}

同步静态方法的锁对象：类名.class

public class SellTicket implements Runnable{
//    private int ticket=1000;
    private static int ticket=1000;
    private Object obj=new Object();//三个线程要用同一把锁，所以放一个obj变量在这
    private int x=0;
    @Override
    public void run() {
        while(true){
            if(x%2==0){
//                synchronized (obj){
//                synchronized (this){//同步方法的锁对象：this
                synchronized (SellTicket.class){//同步静态方法的锁对象：该类的字节码文件对象
                    if(ticket>0){
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                        ticket--;
                    }
                }
            }else{
                sellTicket();
            }
            x++;
        }
    }

    private static synchronized void sellTicket() {
        if(ticket>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
            ticket--;
        }
    }
}

3. 几个线程安全的类

（1）StringBuffer

• 线程安全，可变的字符序列，源码中的方法都加了synchronized

• 如果不需要同步，应使用StringBuilder替代

（2）Vector

• 改进了List接口，使其成为Java Collections Framework的成员

• 如果不需要线程安全，应使用ArrayList替代

（3）Hashtable

• 实现了一个哈希表，任何非null值可作为键或值

• 如果不需要同步，建议使用Hashmap替代（Hashmap允许键或值均可为null，而Hashtable均不可）

（4）工具类转为线程安全

举例：

List<String> synList = Collections.synchronizedList(new ArrayList<>());

4. Lock锁

为了体现更为清晰而广泛的加锁释放锁过程，JDK5之后提供了一个新的锁对象Lock

void lock() //获得锁
void unlock() //释放锁

Lock是接口不能直接实例化，可以采用它的实现类ReentrantLock来实例化

public class SellTicket implements Runnable{
    private int ticket=1000;
    private Lock lock =new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {//常用try-finally块，即使代码出问题也会释放锁
                lock.lock();
                if(ticket>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                    ticket--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

 5. volatile关键字

（1）volatile是一种轻量级的同步机制，相比于synchronized和Lock（synchronized通常称为重量级锁），volatile更轻量级；

（2）volatile可以保证线程可见性且提供了一定的有序性，但是无法保证原子性，所以不能用于非原子操作（赋值是原子操作）；

（3）volatile用于修饰类变量或成员变量，被修饰的变量在缓存中的修改会被立即写入主存（一般变量只是先写入线程私有的本地内存）；

（4）volatile在操作系统底层是内存屏障的原语，用于解决可见性和有序性问题；

（5）应用场景：单例模式

public class TestInstance{
    private volatile static TestInstance instance;
    
    public static TestInstance getInstance(){        //1
        if(instance == null){                        //2
            synchronized(TestInstance.class){        //3
                if(instance == null){                //4
                    instance = new TestInstance();   //5
                }
            }
        }
        return instance;                             //6
    }
}

如果不用volatile，第五行代码在多线程情况下会出现问题，因为instance = new TestInstance(); 事实上有三个执行步骤

a. memory = allocate() //分配内存

b. ctorInstanc(memory) //初始化对象
 
c. instance = memory //设置instance指向刚分配的地址

由于可能存在指令重排，如果一个进程1先执行了ac，另一个线程b判断instance == null就会认为是false，产生错误。

三. 生产者消费者模型

Java在Object类提供了一些方法，体现生产和消费过程中的等待和唤醒：

void wait() //使当前线程等待，直到另一个线程调用此对象的notify()或notifyAll()方法
void notify() //唤醒一个在这个对象的监视器上等待的单个线程
void notifyAll() //唤醒正在等待此对象监视器上的所有线程

• 这些方法需要在同步的条件下，一般配合synchronized使用

• 如果等待的线程有多个，notify方法只会唤醒其中一个，唤醒哪一个取决于操作系统对于多线程的管理

• notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况

生产者消费者代码示例：

public class Box {
    //成员变量，表示第x件商品
    private int good;
    //表示箱内是否有商品
    private  boolean state=false;

    public synchronized void put(int good) {//注意要加synchronized关键字，否则wait()抛异常
        if(state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.good = good;
        System.out.println("生产者将第"+this.good+"件商品放入箱中");
        state=true;
        notifyAll();
    }

    public synchronized void get() {
        if(!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费者拿到第"+good+"件商品");
        state=false;
        notifyAll();
    }
}

public class Producer implements Runnable{
    private Box b;

    public Producer(Box b){
        this.b=b;
    }
    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            b.put(i);
        }
    }
}

public class Customer implements Runnable{
    private Box b;
    public Customer(Box b){
        this.b=b;
    }
    @Override
    public void run() {
        while(true){
            b.get();
        }
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        Box b=new Box();//存储箱类
        Producer p=new Producer(b);//生产者对象
        Customer c=new Customer(b);//消费者对象
        Thread t1=new Thread(p);//生产者线程
        Thread t2=new Thread(c);//消费者线程
        t1.start();//启动线程
        t2.start();
    }
}

输出：