Java多线程学习

作者: 等酒香醇V | 来源:发表于2017-12-19 18:59 被阅读0次

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

线程的实现

线程有两种实现方式，集成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：尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的。

Java多线程学习

线程的实现

线程安全

线程中断

线程优先级

notify/wait

Lock的使用

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

读写锁

定时器

线程池

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读