多线程

一下仅做个人学习总结用。

一、多线程概述

1.实现多线程的方法

1).继承Thread类

package com.zqj.thread.extendthread;

public class Run {

    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        mythread.start();
        System.out.println("运行结束");
    }
}

class Mythread extends Thread{
    public void run(){
        System.out.println("extend Thread");
    }
}

运行结果：

Tips：

• 线程被调用的时间是随机的；
• 使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序是无关的；
• 在上面代码中也可以使用“mythread.run();”来启动线程。与使用start方法的区别是：使用start方法启动时通知“线程规划器”此线程已经准备好，让系统安排一个时间来调用run()启动线程；而直接调用run()是由main主线程来调用run()，必须等run()里面的代码执行完才能执行后面的代码，是同步执行；
• 当启动多个线程时，start()的顺序不代表线程的启动的顺序；

2).实现Runnable接口

package com.zqj.thread.extendthread;

public class Run {

    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        System.out.println("运行结束");
    }
}

class MyRunnable implements Runnable{
    public void run(){
        System.out.println("extend Thread");
    }
}

运行结果：

Tips：

• Thread类也实现了Runnanle接口
• 构造函数Thread(Runnable target)不光可以传入Runnable接口的对象，还可以传入一个Thread对象。这样可以将一个Thread对象的run()方法教给其他线程调用

3.线程中的一些方法

• currentThread()：返回代码段正在被哪个线程调用的信息
• isAlive()：判断当前线程是否处于活动状态
• sleep()：休眠当前正在执行的线程
• getId()：获取线程的唯一标识
• yield()：放弃当前CPU资源，但时间不确定，可能刚放弃又马上获得CPU时间片

二、对象及变量的并发访问

1.实例变量的非线程安全问题

package com.zqj.thread.extendthread;

public class TestRun {

    public static void main(String[] args) {
        HasSelfPrivateNum nunRef = new HasSelfPrivateNum();
        ThreadA threadA = new ThreadA(nunRef);
        threadA.start();
        ThreadB threadB = new ThreadB(nunRef);
        threadB.start();
    }
}

class HasSelfPrivateNum{
    private int num = 0;
    public void addI(String username){
        try {
            if(username.equals("a")){
                num = 100;
                System.out.println("a set over");
                Thread.sleep(2000);
            }else {
                num = 200;
                System.out.println("b set over");
            }
            System.out.println(username + " num=" +num);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    private HasSelfPrivateNum numRef;
    public ThreadA(HasSelfPrivateNum numRef){
        this.numRef = numRef;
    }
    public void run(){
        numRef.addI("a");
    }
}

class ThreadB extends Thread{
    private HasSelfPrivateNum numRef;
    public ThreadB(HasSelfPrivateNum numRef){
        this.numRef = numRef;
    }
    public void run(){
        numRef.addI("b");
    }
}

执行结果：

num作为方法中的公有变量，两个线程同时访问时发生数据不一致。A线程未执行完，B线程进入了，改变了num的值，导致a  num =200;如果在public void addI(String username)方法前加入关键字synchronized，可使两个线程同步。

Tips：

• synchronized关键字取得的锁都是对象锁
• 哪个线程先执行带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁，其他线程只能等待；前提是多个线程访问的是同一个对象
• 如果访问多个对象，JVM会创建多个锁
• synchronized锁可重入，即同一个线程在得到这个对象锁时，可以再次获得该对象锁；
• 线程出现异常，锁会自动释放
• 同步不能继承，子类方法仍然需要添加synchronized关键字

2.synchronized同步语句块

synchronized同步语句块可以对某一段代码使用，仅使这一段代码具有同步性；让其他线程可以执行方法中其他不需要同步的地方，提高代码执行效率

synchronized(this)锁定当前对象，synchronized也可以锁定其他任意对象

synchronized加在static方法上时是给Class类加锁，加到非static方法是给对象加锁；这两种锁是不同的，Class锁可以对类的所有实例起作用。synchronized(class)代码块的作用和synchronized static方法一样

3.volatile关键字

volatile关键字的作用是使变量在多个线程可见，强制从公共堆中取得变量的值，而不是从线程私有数据栈中取得变量的值。

package com.zqj.thread.volatiles;

public class TestRun {

    public static void main(String[] args) {
        try {
            RunThread thread = new RunThread();
            thread.start();
            Thread.sleep(1000);
            thread.setRunning(false);
            System.out.println("已经被赋值为false");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class RunThread extends Thread{
    private boolean isRunning = true;

    public boolean isRunning() {
        return isRunning;
    }

    public void setRunning(boolean running) {
        this.isRunning = running;
    }

    public void run(){
        System.out.println("进入run");
        while (isRunning == true){

        }
        System.out.println("线程被停止了");
    }
}

运行结果：

在上面的代码中，变量private boolean isRunning = true;存在于公共堆栈和线程的私有堆栈中。而线程从私有堆栈中取得的isRunning的值一直是true。thread.setRunning(false);虽然被执行但更新的却是共有堆栈中的isRunning值变为false。所以使用volatile关键字定义isRunning，使得当线程访问isRunning变量时强制从公共堆栈取值。

修改为volatile private boolean isRunning = true;后运行结果：

4.volatile和synchronized的比较

Tips：

• vloatile只用于修饰变量；而synchronized可用于修饰方法及代码块
• 多线程访问volatile不会发生阻塞，而synchronized会阻塞
• volatile只能保证数据的可见性，不能保证原子性；而synchronized可以保证原子性，可以间接保证数据可见性，因为synchronized会将私有内存和公共内存中的数据同步
• 关键字volatile解决的是变量在多个线程之间的可见性；而synchronized解决的是多个线程之间访问资源的同步性

三、线程间的通信

1、等待/通知机制

wait()方法释放当前线程持有的锁，立即释放

notify()方通知那些等待对象锁的其他线程，线程规划器随机挑选一个wait状态的线程唤醒。notify()方法所在线程代码执行完后才释放锁

notifyAll()方法唤醒所有wait中的线程，但这些线程也只会随机执行一个

2.线程状态

运行态、等待态、阻塞态；线程状态之间的切换示意图如下：

3.类ThreadLocal的使用

变量的值共享可以使用public static变量的形式，所有的线程都使用同一个public static变量。如果想要实现每一个线程都有自己共享变量，可以使用ThreadLocal解决。类ThreadLocal解决每个线程绑定自己的值。

package com.zqj.thread.threadloc;

public class RunThreadLocal {

    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();
        threadA.start();
        threadB.start();
    }
}

class Tools{
    public static ThreadLocal t1 = new ThreadLocal();
}
class ThreadA extends Thread{
    @Override
    public void run() {
        try {
            for(int i = 0;i < 10;i++){
                Tools.t1.set("ThreadA"+(i+1));
                System.out.println("ThreadA get Value"+Tools.t1.get());
                Thread.sleep(200);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{
    @Override
    public void run() {
        try {
            for(int i = 0;i < 10;i++){
                Tools.t1.set("ThreadB"+(i+1));
                System.out.println("ThreadB get Value"+Tools.t1.get());
                Thread.sleep(200);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

上面代码中虽然两个线程都向t1对象中set()数据，但每个线程还是能取到自己的数据。

四、Lock的使用

1.使用RenntrantLock类

使用方法：定义一个锁Lock lock = new RenntrantLock(); 使用lock.lock();和 lock.unlock();为包围的代码块上锁；

2.使用Condition实现等待/通知

使用ReentrantLock结合Condition类可以实现“选择性通知”；使用Condition类可以唤醒部分指定线程

package com.zqj.thread.reentrantlock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionReen {

    public static void main(String[] args) throws InterruptedException{
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(3000);
        service.signallAll_A();
    }
}

class MyService{
    private Lock lock = new ReentrantLock();
    public Condition conditionA = lock.newCondition();
    public Condition conditionB = lock.newCondition();

    public void awaitA(){
        try {
            lock.lock();
            System.out.println("begin awaitA 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
            conditionA.await();
            System.out.println("end awaitA时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitB(){
        try {
            lock.lock();
            System.out.println("begin awaitB 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
            conditionB.await();
            System.out.println("end awaitB时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signallAll_A(){
        try {
            lock.lock();
            System.out.println("signallAll_A 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
            conditionA.signalAll();
        }finally {
            lock.unlock();
        }
    }

    public void signallAll_B(){
        try {
            lock.lock();
            System.out.println("signallAll_B 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
            conditionA.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread{
    private MyService service;

    public ThreadA(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitA();
    }
}

class ThreadB extends Thread{
    private MyService service;

    public ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitB();
    }
}

运行结果：

运行程序后，只有线程A被唤醒了。

3.一些方法

• int getHoldCount()：查询当前线程保持此锁定的个数
• int getQueueLength：返回正在等待获取此锁定的线程估计数；比如有5个线程，一个线程首先执行await()方法，在调用getQueueLength()方法后返回值是4，说明有4个线程在等待lock释放
• int getWaitQueueLength(Condition condition)：作用是返回等待  与此线程相关的给定条件Condition的估计数；比如有5个线程，每个线程都执行了同一个Condition对象的await()方法，则调用getWaitQueueLength(Condition condition)方法时返回值是5
• boolean hasQueueThread()：作用是查询指定的线程是否正等待获取此锁定。用法如lock.hasQueueThread(threadA)
• boolean hasWaiters(Condition condition)：作用是查询是否有线程正在等待与此锁定有关的condition；用法如lock.hasWaiters(conditionA)
• boolean isFair()：作用是判断是不是公平锁；默认情况下，ReentrantLock类使用的非公平锁。
• boolean isHeldByCurrentThread()：作用是查询当前线程是否持有此锁定
• boolean isLocked()：作用是查询此锁定是否由任意线程保持
• lockInterruptibly()：如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常
• boolean tryLock()：仅在调用时锁定未被另一个线程保持的情况下，才获取此锁定
• boolean tryLock(long timeout,TimeUnit unit)：如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定

4.使用ReentrantReadWriteLock类

一个是读操作相关的锁readLock()，也称为共享锁；另一个是写操作的相关的锁writeLock()，也叫排他锁。多个读锁之间不互斥，读锁和写锁互斥，写锁和写锁之间互斥。在没有线程进入写入操作时，进行读取的多个线程都可以获取读锁，而进入写入操作的线程只有在获取写锁后才能进入写入操作。即多个线程可以同时进行读取操作，但是同一时刻只允许一个线程进入写入操作