Java多线程学习

本篇注重实现，理论概念不深入。

线程的实现

线程有两种实现方式，集成Thread类和实现Runnable接口。由于java不能实现多集成，所以推荐使用实现接口的方式。

//集成Thread
public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("test thread");
    }

}

//使用方法
MyThread thread = new MyThread();
thread.start();


//实现Runnable接口
public class MyThread implements Runnable {

    @Override
    public void run() {
        System.out.println("test thread");
    }

}

//使用方法
Thread thread = new Thread(new MyThread());
thread.start();

线程安全

当多个线程并发访问同一个资源时，线程本身不能保证得到的资源是否被其他线程访问、篡改过，这种情况就是线程不安全。

//线程不安全情况模拟
public void run() {
    while (Producer.count > 0) {
        System.out.println("线程" + Thread.currentThread().getName() + "  总量" + Producer.count--);
    }
}
    
MyThread t = new MyThread();
Thread a = new Thread(t, "a");
Thread b = new Thread(t, "b");
Thread c = new Thread(t, "c");
Thread d = new Thread(t, "d");
a.start();
b.start();
c.start();
d.start();


// 结果是随机的，此处找出不安全的情况来说明，可以看出有重复利用的结果
线程c  总量10
线程a  总量8
线程a  总量6
线程b  总量9
线程b  总量4
线程b  总量3
线程b  总量2
线程b  总量1
线程d  总量9
线程a  总量5
线程c  总量7

使用synchronized实现线程安全

//实现，在线程中不能使用循环来进行count--，否则同步的时候，其他线程得不到资源。
public void run() {
    synchronized (this) {
        if (Producer.count <= 0) {
            System.out.println("线程" + Thread.currentThread().getName() + " 出售完了");
        } else {
            System.out.println("线程" + Thread.currentThread().getName() + "  总量" + Producer.count--);
        }
    }
}

//使用
while (Producer.count > 0) {
    Thread a = new Thread(new MyThread());
    a.start();
}

synchronized的使用方法

修饰一个代码块

synchronized (this) {
    // todo
}

修饰一个方法

public synchronized void methods() {
    // todo
}

public synchronized static void methods() {
   // todo
}

修饰一个对象

private Account account;


public void run() {
  synchronized (account) {
        // todo
  }
}

修饰一个类，synchronized作用于一个类T时，是给这个类T加锁，T的所有对象用的是同一把锁

synchronized(ClassName.class) {
 // todo
}

线程中断

使用interrupt()发送中断请求。

public void run() {
    while (true) {
        if (Thread.currentThread().isInterrupted()) {
            break;
        }
    }
}
//异常停止
public void run() {
    try {
        Thread.sleep(10000000);
    } catch (InterruptedException ex) {
        System.out.println("线程中断了");
    }
}

线程优先级

线程优先级有1-10，10个级别，默认是5。使用如下

Thread a = new Thread(new MyThread(), "a");
a.setPriority(10);

notify/wait

线程可以通过notify/wait来进行等待唤醒，通过这种方式来更好的释放和启用资源，避免资源长期被占用。notify/wait必须在同步的环境中使用，否则会报java.lang.IllegalMonitorStateException异常。一组notify/wait必须是同一个锁。

基于notify/wait的生产者与消费者

public class Car {

    private int total = 0;
    private int maxSize = 5;

    synchronized public void create() throws InterruptedException {
        if (total < maxSize) {
            this.total++;
            System.out.println(Thread.currentThread().getName() + "生成了一个，库存：" + total);
            this.notifyAll();
        } else {
            System.out.println(Thread.currentThread().getName() + "库存满了");
            this.wait();
        }
    }

    synchronized public void delete() throws InterruptedException {
        if (total > 0) {
            this.total--;
            System.out.println(Thread.currentThread().getName() + "消费了一个，库存：" + total);
            this.notifyAll();
        } else {
            System.out.println(Thread.currentThread().getName() + "消费完了");
            this.wait();
        }
    }

}


public class Producer extends Thread {

    private Car car;

    public Producer(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        try {
            while (true) {
                car.create();
            }
        } catch (InterruptedException ex) {
            Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

public class Customer extends Thread {

    private Car car;

    public Customer(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        try {
            while (true) {
                car.delete();
            }
        } catch (InterruptedException ex) {
            Logger.getLogger(Customer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

public static void main(String[] args) {
    Car car = new Car();
    new Producer(car).start();
    new Customer(car).start();
    new Customer(car).start();
}

//结果
Thread-0生成了一个，库存：1
Thread-0生成了一个，库存：2
Thread-0生成了一个，库存：3
Thread-0生成了一个，库存：4
Thread-0生成了一个，库存：5
Thread-0库存满了
Thread-1消费了一个，库存：4
Thread-1消费了一个，库存：3
Thread-1消费了一个，库存：2
Thread-1消费了一个，库存：1
Thread-1消费了一个，库存：0
Thread-0生成了一个，库存：1
Thread-0生成了一个，库存：2
Thread-0生成了一个，库存：3
Thread-0生成了一个，库存：4
Thread-0生成了一个，库存：5
Thread-0库存满了
Thread-2消费了一个，库存：4
Thread-2消费了一个，库存：3
Thread-2消费了一个，库存：2
Thread-2消费了一个，库存：1
Thread-2消费了一个，库存：0
Thread-2消费完了
Thread-0生成了一个，库存：1
Thread-0生成了一个，库存：2
Thread-0生成了一个，库存：3
Thread-0生成了一个，库存：4
Thread-0生成了一个，库存：5
Thread-0库存满了

Lock的使用

在上面介绍了通过synchronized来进行同步，从JDK1.5开始，通过使用ReentrantLock也能达到同样的效果，并且还拥有更多的扩展功能。

    private int total = 0;
    private int maxSize = 5;
    Lock lock = new ReentrantLock();
    Condition cCondition = lock.newCondition();
    Condition pCondition = lock.newCondition();

    public void create() throws InterruptedException {
        lock.lock();
        try {
            if (total < maxSize) {
                this.total++;
                System.out.println(Thread.currentThread().getName() + "生成了一个，库存：" + total);
                cCondition.signalAll();
            } else {
                System.out.println(Thread.currentThread().getName() + "库存满了");
                pCondition.await();
            }
        } finally {
            lock.unlock();
        }
    }

    public void delete() throws InterruptedException {
        lock.lock();
        try {
            if (total > 0) {
                this.total--;
                System.out.println(Thread.currentThread().getName() + "消费了一个，库存：" + total);
                pCondition.signalAll();
            } else {
                System.out.println(Thread.currentThread().getName() + "消费完了");
                cCondition.await();
            }
        } finally {
            lock.unlock();
        }
    }

BlockingQueue阻塞队列的消费者生产者

推荐使用这种模式，但是获取list.szie是不同步的。

public class Car {

    private int total = 1;
    private int maxSize = 5;
    private LinkedBlockingQueue list = new LinkedBlockingQueue(100);

    public void create() throws InterruptedException {
        if (list.size() < maxSize) {
            list.put(total++);
            System.out.println(Thread.currentThread().getName() + "生成了一个，库存：" + list.size() + " :" + System.currentTimeMillis());
        } else {
            System.out.println(Thread.currentThread().getName() + "库存满了" + System.currentTimeMillis());
        }
    }

    public void delete() throws InterruptedException {
        //list.size()并不同步
        Object o = list.take();
        if (o != null) {
            System.out.println(Thread.currentThread().getName() + "消费了" + o + "，库存：" + list.size() + " :" + System.currentTimeMillis());
        } else {
            System.out.println(Thread.currentThread().getName() + "消费完了" + System.currentTimeMillis());
        }
    }

}

读写锁

java提供了ReentrantReadWriteLock类来实现读写分离，其中读读共享，读写、写写、写读互斥。

    public void read() throws InterruptedException {
        lock1.readLock().lock();
        try {
            System.out.println("读锁" + System.currentTimeMillis());
            Thread.sleep(1000);
        } finally {
            lock1.readLock().unlock();
        }
    }

    public void write() throws InterruptedException {
        lock1.writeLock().lock();
        try {
            System.out.println("写锁" + System.currentTimeMillis());
            Thread.sleep(1000);
        } finally {
            lock1.writeLock().unlock();
        }
    }
    
//测试结果-读读  
读锁1513584894182  
读锁1513584894182  
读锁1513584894182  
读锁1513584894183  


//测试结果-写写  
写锁1513584863617  
写锁1513584864618  
写锁1513584865618  
写锁1513584866619  

//测试结果-写读  
写锁1513584924267  
写锁1513584925268  
写锁1513584926268  
写锁1513584927269  
读锁1513584928269  
读锁1513584928269  
读锁1513584928271  
读锁1513584928271  

//测试结果-读写  
读锁1513584954882  
读锁1513584954882  
读锁1513584954882  
读锁1513584954883  
写锁1513584955883  
写锁1513584956884  
写锁1513584957884  
写锁1513584958884

定时器

定时器是通过继承TimerTask这个类来实现。

public class MyTimer extends TimerTask {

    @Override
    public void run() {
        System.out.println("定时器打印" + System.currentTimeMillis());
    }

}

使用方式有以下六种

schedule(TimerTask task, Date time) //在time时刻执行一次定时任务
schedule(TimerTask task, long delay) //在delay毫秒后执行一次定时任务
schedule(TimerTask task, Date firstTime, long period) //在firsttime时间开始执行，之后间隔period毫秒后重复执行任务
schedule(TimerTask task, long delay, long period) //在delay毫秒后开始执行，之后间隔period毫秒后重复执行任务
scheduleAtFixedRate(TimerTask task, Date firstTime,long period) //同schedule，差异参考
scheduleAtFixedRate(TimerTask task, long delay, long period) //同schedule，差异参考

MyTimer time = new MyTimer();
Timer t = new Timer();
t.schedule(time, 0, 1000);

Timer是单线程模式，调度多个周期性任务时，如果某个任务耗时较久就会影响其它任务的调度；如果某个任务出现异常而没有被catch则可能导致唯一的线程死掉而所有任务都不会再被调度。在jdk1.5之后，可以使用
ScheduledExecutorService来执行周期性任务。

ScheduledExecutorService schedule = Executors.newScheduledThreadPool(2);
schedule.schedule(new ThreadMonitor(), 60l, TimeUnit.SECONDS);
schedule.schedule(new AlarmSenderThread("Alarm" + startTime), 0, TimeUnit.SECONDS);
schedule.shutdown();

线程池

当我们使用多线程时，会用到线程池来进行线程的管理和调度。线程池的类图如下，参考此文

Threadpool.png

一般的线程池可以使用ThreadPoolExecutor，需要执行定时、延迟等功能时使用ScheduledThreadPoolExecutor。

//最简单的线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);  
  
executorService.execute(new Runnable() {  
    public void run() {  
        System.out.println("Asynchronous task");  
    }  
});  
  
executorService.shutdown();

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

submit/execute

添加线程到线程池，是ExecutorService的两个方法。区别： submit有返回值，返回future，execute没有。返回值future的用处是可以执行cancle方法，取消执行。可以通过get()方法，判断是否执行成功 ==null表示执行成功。

shutdown/shutdownNow

当使用 ExecutorService 完毕之后，我们应该关闭它，这样才能保证线程不会继续保持运行状态。shutdown:调用此方法后，ExecutorService将不会再接受新任务，直到所有任务完成后关闭。
shutdownNow：尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的。

最后编辑于：2018.02.06 23:57:18

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 214,658评论 6赞 496
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,482评论 3赞 389
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 160,213评论 0赞 350
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,395评论 1赞 288
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,487评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,523评论 1赞 293
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,525评论 3赞 414
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,300评论 0赞 270
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,753评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,048评论 2赞 330
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,223评论 1赞 343
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,905评论 5赞 338
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,541评论 3赞 322
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,168评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,417评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,094评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,088评论 2赞 352

Java多线程学习

线程的实现

线程安全

线程中断

线程优先级

notify/wait

Lock的使用

BlockingQueue阻塞队列的消费者生产者

读写锁

定时器

线程池

推荐阅读更多精彩内容