Java多线程、并发

 

    并发编程使我们可以将程序划分为多个分离的、独立运行的任务。通过多线程机制，这些独立的任务中的每一个都将由执行线程来驱动。单个进程可以拥有多个并发执行任务。
    实现并发最直接的方式是在操作系统级别使用进程。
    Java的线程机制是抢占式的，调度机制会周期性的中断线程，将上下文切换到另一个线程，从而为每个线程都提供时间片，使得每个线程都会分配到数量合理的赶时间去驱动它的任务。还有一种方式是协作式，这种需要程序主动去释放线程控制权。

一、多线程使用

1、继承Runnable接口

public class MyRunnable implements Runnable {
    private int index;
    @Override
    public void run() {
        while (index ++ < 10){
            System.out.print(index + ",");
            Thread.yield();//可选使用，用来告诉线程调试器，当前任务已执行完，可以切换线程了
        }
    }
    public static void main(String[] args) {
        //启用新线程
        new Thread(new MyRunnable()).start();
        new Thread(new MyRunnable()).start();
        System.out.println("main ended");
    }
}

结果：

main ended
1,2,1,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,

相关参数设置：

    Thread thread1 = new Thread(new MyRunnable());
    //设置thread1为后台线程，程序会在所有非后台线程运行结束后结束，而不关心后台线程是否已经结束了。
    thread1.setDaemon(true);
    thread1.setName("threadname");//设置线程名称
    thread1.start();

    Thread thread2 = new Thread(new MyRunnable());
    thread2.start();
    try {
        thread2.join(6000); //主线程会在此等待thread2执行完，最多等待6秒，如果不设置超时时间则一直等待
        thread2.interrupt();//取消等待，这个与join在同一个线程执行是没有效果的。
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

使用Executors来管理线程：

    //SE5后可以使用Executors来管理线程
    ExecutorService pool = Executors.newCachedThreadPool();
    //相似的还有FixedThreadPool(固定线程)， SingleThreadExecutor单线程（如果有多个任务会排队）
//  Executors.newFixedThreadPool(10);
//  Executors.newSingleThreadExecutor();
    pool.execute(new MyRunnable());
    pool.shutdown();//shutdown后就不能添加新的线程任务了

使用Executors来执行线程还可以获取到线程内的异常getUncaughtExceptionHandler；   

2、继承Callable接口

可获取线程任务返回值

public class MyCallable implements Callable<String> {
    private int index;
    @Override
    public String call() throws Exception {
        while (index ++ < 10){
            System.out.print(index + ",");
        }
        return "success";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newCachedThreadPool();
        Future<String> result = pool.submit(new MyCallable());
        result.isDone();  //返回当前任务是否已经完成，未完成时调用get()会一直阻塞，直到完成返回结果为止
        System.out.println(result.get()); //success
    }
}

 

二、共享资源加锁

1、synchronized关键字

可使用synchronized关键字来修饰方法，防止资源冲突。
如：synchronized void f(){}
    synchronized void g(){}
当在对象上调用其任意synchronized方法时，此对象都会被加锁，此时该对象上的其他synchronized方法只有等前一个方法调用完毕释放锁之后才能被调用。
以上如某个任务对对象调用了f(),对于同一个对象而言，就只能等f()调用结束并释放锁之后其他任务才能调用f()和g()。所以对于某个特定对象来说synchronized共享同一个锁。
但同一个任务可多次获得对象锁，如果f()调用了g()，也是可以的，这时锁的计数就是2，只有当锁的计数变为0时，锁才会被释放。
注意在使用并发时，将被共享资源的域设置为private是非常重要的，否则synchronized关键字就不能防止其他任务直接访问域。
示例：

//多线程计数
public class SynchObject {
    private Integer index = 0 ;
    synchronized public void counting(){
        while (index ++ < 10){
            System.out.printf(index + ",");
            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class SyncTesthRunnable implements Runnable {
    SynchObject synchObject;
    SyncTesthRunnable(SynchObject synchObject){
        this.synchObject = synchObject;
    }
    @Override
    public void run() {
    
    
        this.synchObject.counting();
    }
    public static void main(String[] args){
        SynchObject synchObject = new SynchObject();
        new Thread(new SyncTesthRunnable(synchObject)).start();
        new Thread(new SyncTesthRunnable(synchObject)).start();
    }
}

如果counting方法不加synchronized关键字，计数的结果就不会是顺序的；
不加synchronized时的运行结果：2,2,3,3,4,5,7,7,8,9,10,
加synchronized时的运行结果：1,2,3,4,5,6,7,8,9,10,

2、显示的使用锁Lock对象来加锁

使用如下：

public class SynchObject {
    private Integer index = 0 ;
    private Lock lock = new ReentrantLock();

    public void counting(){
        lock.lock();
        while (index ++ < 10){
            System.out.printf(index + ",");
            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lock.unlock();//注意锁一定要主动释放，不然其他任务就永远获取不到锁。最好能放在finally里，以防异常发生无法释放锁。
    }
}

如果在synchronized里事务失败了则会抛出异常，我们没有机会去做一些清理工作。使用Lock锁则可以做更多的动作。通常使用synchronized就足够了，只有在解决特殊问题时才显示使用Lock对象。
*在类中只有一个可变域，且对域只进行原子操作时，可使用volatile关键字来限定域，确保同步。但最好不要用，很可能因为理解不到位出现同步问题，一般都推荐直接使用synchronized。
*什么是原子操作？对域中(除long,double外的基本类型)的值做赋值和返回值操作通常都是原子性的。如果域有递增递减操作的肯定不是原子操作。

3、临界区

只对方法内的部分代码加锁

    synchronized(synchObject){
        //这个代码块里的代码只能同时被一个线程访问，也称为同步控制块
    }

 

三、中断线程

ExecutorService exec = Executors.newCachedThreadPool();
Future<String> future = exec.submit(new MyCallable());
future.cancel(true);//方式一
exec.shutdownNow();//方式二
Thread.interrupted();// 检查当前线程是否中断

 

四、线程间协作

1、wait(),notifyAll()/notify()

public class SynchObject {
    private boolean waked = false;

    public synchronized void wakeup() throws InterruptedException {
        Thread.sleep(1000L);//sleep()和yield()方法不会释放锁, wait()会释放锁
        waked = true;
        System.out.println("wake up");
        notifyAll(); //notifyAll()唤醒所有的等待，notify()只唤醒一个。如果确定只有一个可以使用notify来进行优化，其他情况建议使用notifyAll
    }
    public synchronized void getup() throws InterruptedException {
        while (!waked){//wait一般注意要加判断条件，因为不能确定哪个线程先执行，不判断可能造成选notify了再wait，那么就可能一直等不到通知，造成线程一直挂起
            System.out.println("waiting");
            wait(); //wait和notify方法都需要使用synchronized锁定对象线程，否则会报IllegalMonitorStateException异常
        }
        System.out.println("get up");
    }

    public class WakeupTask implements Runnable{
        private SynchObject object;
        WakeupTask(SynchObject object){this.object = object;}
        public void run() {
            try {
                this.object.wakeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public class GetupTask implements Runnable{
        private SynchObject object;
        GetupTask(SynchObject object){this.object = object;}
        public void run() {
            try {
                this.object.getup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void test() {
        SynchObject object = new SynchObject();
        WakeupTask wakeupTask = new WakeupTask(object);
        GetupTask getupTask = new GetupTask(object);
        new Thread(getupTask).start();
        new Thread(wakeupTask).start();
    }
}

-------
test()运行结果：
waiting
wake up
get up

2、生产-消费者与队列

更高效的协作

class Person{
    private String name;
    Person(String name){this.name = name; }
    void wakeup(){System.out.println(name + " wake up");}
    void getup() throws InterruptedException {
        Thread.sleep((long) (1000L * Math.random()));
        System.out.println(name + "get up");
    }
    void working(){System.out.println(name + " working");}
}
class PersonQueue extends LinkedBlockingQueue<Person>{}

class WakedPerson implements Runnable{
    private PersonQueue personQueue;
    public WakedPerson(PersonQueue personQueue){this.personQueue = personQueue;}

    public void run() {
        for (Integer i = 0; i< 5; i++){
            Person p = new Person(i.toString());
            p.wakeup();
            personQueue.add(p);//也可用put()
        }
    }
}
class GetupPerson implements Runnable{
    private PersonQueue wakedQueue;
    private PersonQueue gotupQueue;
    GetupPerson (PersonQueue personQueue, PersonQueue gotupQueue){
        this.wakedQueue = personQueue;
        this.gotupQueue = gotupQueue;
    }
    public void run(){
        try {
            while (!Thread.interrupted()){
                Person p = wakedQueue.take();
                p.getup();
                gotupQueue.put(p);
            }
        } catch (InterruptedException e) {
            System.out.println("GetupPerson thread ended");
        }
    }
}
class WorkingPerson implements Runnable{
    private PersonQueue gotupQueue;
    WorkingPerson(PersonQueue gotupQueue){this.gotupQueue = gotupQueue; }
    public void run(){
        try {
            while (!Thread.interrupted()){
                Person p = gotupQueue.take();
                p.working();
            }
        } catch (InterruptedException e){
            System.out.println("WorkingPerson thread ended");
        }
    }
}

void test() throws InterruptedException {
    PersonQueue personQueue = new PersonQueue();
    PersonQueue gotupQueue = new PersonQueue();
    ExecutorService exec = Executors.newCachedThreadPool();
    exec.execute(new WakedPerson(personQueue));
    exec.execute(new GetupPerson(personQueue, gotupQueue));
    exec.execute(new WorkingPerson(gotupQueue));
    //后两个线程的写法不会主动结束，这里有需要的话可以主动结束
    TimeUnit.SECONDS.sleep(5L);
    exec.shutdownNow();
}

----------
test()运行结果：
0 wake up
1 wake up
2 wake up
3 wake up
0get up
0 working
1get up
1 working
2get up
2 working
3get up
3 working
GetupPerson thread ended
WorkingPerson thread ended

3、管道通信

另一种协作，不同平台之间可能存在差异，相对而言BlockingQueue更健壮

class Sender implements Runnable{
    private Random random = new Random(46);
    private PipedWriter writer = new PipedWriter();
    public PipedWriter getWriter(){return writer;}
    public void run() {
        for (char i = 'A'; i < 'G'; i++){
            try {
                writer.write(i);
                TimeUnit.MILLISECONDS.sleep(random.nextInt(500));
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Receiver implements Runnable{
    private PipedReader reader;
    Receiver(Sender sender) throws IOException {
        this.reader = new PipedReader(sender.getWriter());
    }
    public void run(){
        while (true){
            try {
                System.out.println("read: " + (char)reader.read());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
void test() throws IOException {
    Sender sender = new Sender();
    Receiver receiver = new Receiver(sender);
    ExecutorService excu = Executors.newCachedThreadPool();
    excu.execute(receiver);
    excu.execute(sender);
}

----------
test()运行结果：
read: A
read: B
read: C
read: D
read: E
read: F

 

五、SE5引入的线程处理构件(类)

1、同步一个或多个任务，强制它们等待另一组任务的执行完成（CountDownLatch）

class PreTask implements Runnable{
    private final Integer index;
    private CyclicBarrier cyclicBarrier;
    PreTask(Integer index, CyclicBarrier cyclicBarrier) {
        this.index = index;
        this.cyclicBarrier = cyclicBarrier;
    }
    public void run() {
        try {
            TimeUnit.MILLISECONDS.sleep(100 * index);
            cyclicBarrier.await();
            System.out.print(index + ",");
        } catch (InterruptedException | BrokenBarrierException e) {}
    }
}

class AfterTask{
    private ExecutorService excu = Executors.newCachedThreadPool();
    private CyclicBarrier barrier;
    private int index = 0;

    public void runn(){
        barrier = new CyclicBarrier(3, new Runnable() {//3表示cycle运行了3次才会运行此内容
            @Override
            public void run() {
                System.out.println("AfterTask;");
            }
        });
    }

    public void test(){
        runn();
        for (int index = 0; index < 12; index ++){
            excu.execute(new PreTask(index, barrier));
        }
    }
}

----------
test()运行结果：
AfterTask;
2,0,1,AfterTask;
3,4,5,AfterTask;
6,7,8,AfterTask;
11,9,10,

3、基础优先级队列PriorityBlockingQueue

可以根据优先级执行顺便执行，必须要实现Comparable接口；

class PriorityTask implements Runnable, Comparable{
    private final int index;
    public final int priority = new Random().nextInt(20);
    PriorityTask(int index) {this.index = index;}

    @Override
    public void run() {
        System.out.println(index + " run with priority:" + priority);
    }
    @Override
    public int compareTo(Object o) {
        return this.priority - ((PriorityTask) o).priority;
    }
}
class Consumer implements Runnable{
    private PriorityBlockingQueue<Runnable> queue;
    Consumer(PriorityBlockingQueue<Runnable> queue) { this.queue = queue;}

    @Override
    public void run() {
        while (!Thread.interrupted()){
            try {
                queue.take().run();
            } catch (InterruptedException e) {}
        }
    }
}

void test(){
    ExecutorService excu = Executors.newCachedThreadPool();
    PriorityBlockingQueue<Runnable> queue = new PriorityBlockingQueue<Runnable>();
    for (int index = 1; index < 7; index ++){
        queue.put(new PriorityTask(index));
    }
    excu.execute(new Consumer(queue));
}

----------
test()运行结果：
1 run with priority:1
6 run with priority:3
4 run with priority:8
2 run with priority:10
3 run with priority:15
5 run with priority:16

4、等待执行DelayQueue

等待一段时间后执行，可作超时处理任务之类的工作，其实除去等待时间也是一个优先级队列；

class DelayTask implements Runnable, Delayed{
    private int index;
    int wait = new Random().nextInt(10);
    private Long startTime = System.currentTimeMillis();
    DelayTask(int index){ this.index = index;}
    public int getWait(){return this.wait;}

    //如果两个都在队列里判断谁优先执行(与getDelay的时间无关)，所以一般可以用延迟的时间进行排序
    @Override
    public int compareTo(Delayed o) {
        return wait - ((DelayTask)o).getWait();
    }
    //等待时间,一定要减去当前时间，因为此方法会被持续调用，直到返回值为0或负数时才执行run的方法，返回一个常量的正数，则run一直不会运行。
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(startTime + wait * 1000  - System.currentTimeMillis(),
                TimeUnit.MILLISECONDS);
    }
    @Override
    public void run() {
        System.out.println(index + "waited:" + wait + "s,");
    }
}
class Consumer implements Runnable{
    private DelayQueue<DelayTask> queue;
    Consumer(DelayQueue<DelayTask> queue) {this.queue = queue;}
    @Override
    public void run() {
        while (!Thread.interrupted()){
            try {
                queue.take().run();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

void test(){
    ExecutorService excu = Executors.newCachedThreadPool();
    DelayQueue<DelayTask> queue = new DelayQueue<DelayTask>();
    for (int index = 1; index < 12; index ++){
        queue.put(new DelayTask(index));
    }
    excu.execute(new Consumer(queue));
}

----------
test()运行结果：
4waited:0s,
10waited:1s,
7waited:1s,
11waited:3s,
1waited:3s,
2waited:4s,
8waited:5s,
3waited:7s,
6waited:7s,
5waited:8s,
9waited:8s,

5、定时任务ScheduledThreadPoolExecutor

class ScheduleTask implements Runnable{
    private final String name;
    ScheduleTask(String name) {this.name = name; }

    @Override
    public void run() {
        System.out.println(new Date().toString() + " running " + name);
    }
}
void test() throws InterruptedException {
    ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(10);//线程池容量
    //执行一次
    scheduler.schedule(new ScheduleTask("singletask"), 2, TimeUnit.SECONDS);
    //周期性执行多次
    scheduler.scheduleAtFixedRate(new ScheduleTask("repeatetask"), 1, 4, TimeUnit.SECONDS);
    TimeUnit.SECONDS.sleep(20);
    scheduler.shutdownNow();
}

----------
test()运行结果：
Thu Feb 04 01:08:19 CST 2021 running repeatetask
Thu Feb 04 01:08:20 CST 2021 running singletask
Thu Feb 04 01:08:23 CST 2021 running repeatetask
Thu Feb 04 01:08:27 CST 2021 running repeatetask
Thu Feb 04 01:08:31 CST 2021 running repeatetask
Thu Feb 04 01:08:35 CST 2021 running repeatetask

 

六、其他

1、变量在各线程内时独立的，使用java.lang.ThreadLocal<E>这个类来辅助实现线程本地存储
2、使用Lock通常会比使用synchronized高效许多，但一般可以 synchronized关键字入手，只有在性能调优时替换为Lock对象；Atomic对象只有在非常简单的情况下才有用，通常不使用。
3、线程池的创建方式：
Executors.newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待；
Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程；
Executors.newSingleThreadExecutor：创建单个线程数的线程池，它可以保证先进先出的执行顺序；
Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池；
Executors.newSingleThreadScheduledExecutor：创建一个单线程的可以执行延迟任务的线程池；
Executors.newWorkStealingPool：创建一个抢占式执行的线程池（任务执行顺序不确定）【JDK 1.8 添加】。
ThreadPoolExecutor：最原始的创建线程池的方式，它包含了 7 个参数可供设置，后面会详细讲

参考：线程池的7种创建方式