Java常用高级线程操作

针对Java线程操作一直不太明白,今天找了一本高级教材,有专门介绍Java7支持的线程操作,稍微记录一下各种类和使用条件

1.synchronized对象锁

使用synchronized来锁定一个对象,但是使用在类的方法中的时候会造成整个类的对象被锁,因此对于其他没有此关键字的标记也无法被其他线程操作。

synchronized可以锁定任意代码块,可以锁定任意对对象作为代码块的锁。

2.volatile进行线程同步

volatile作为一个在内存和线程之间同步变量的关键字,不会再本地保存变量的二次拷贝。

3.ReentrantLock超时锁的一个实现,可以实现锁住代码块

在此类对象的.lock()和unlock()之间的代码块是被锁定的块,其下面的方法
lock.tryLock(10, TimeUnit.SECONDS);

可以用来指定超时时间。

4.阻塞队列

这个是针对消费/生产问题的一个实现,一般使用LinkedBlockingQueue来指定具有无限容量的队列,ArrayBlockingQueue是有界的阻塞队列,

还有一个叫LinkedTransferQueue的实现,但是不是太明白书中的例子,应该是一种按需的队列,就是如果队列中有等待使用数据的线程,那么插入数据的线程一旦启动,就会产生需要的所有数据,而一旦没有等待/请求数据的线程,就不产生数据。

5.同步器

信号量Semaphore这个类是用来生成信号量的,信号量的所谓机制就是如果信号量标记有正在处理的事件的时候,所有请求都被驳回,但是如果有空闲就接受请求。

看我写的小例子:

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args){
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return new AtomicInteger(1).incrementAndGet();
            }
        };

Semaphore semaphore = new Semaphore(4,true);

try {
            while (true) {
                if (semaphore.tryAcquire(2, TimeUnit.SECONDS)) {
                    Future<Integer> future = executorService.submit(callable);
                    System.out.println(future.get());
                }
            }
        }catch (InterruptedException e){

}catch (ExecutionException e){

}finally {
            executorService.shutdown();
        }
    }
}

看到的是ExecutorService创建了10个的线程池(姑且称为线程池),但是信号量是四个,那么执行的时候只能看到四个输出;


import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args){
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return new AtomicInteger(1).incrementAndGet();
            }
        };

Semaphore semaphore = new Semaphore(4,true);

try {
            while (true) {
                if (semaphore.tryAcquire(2, TimeUnit.SECONDS)) {
                    Future<Integer> future = executorService.submit(callable);
                    System.out.println(future.get());
                }
                semaphore.release();
            }
        }catch (InterruptedException e){

}catch (ExecutionException e){

}finally {
            executorService.shutdown();
        }
    }
}

这段是加上了一个叫release的semaphore的方法,此方法释放一个信号量许可,并返回给semaphore。

6.屏障

内容版权声明:除非注明,否则皆为本站原创文章。

转载注明出处:https://www.heiqu.com/f7c86c26ec80f83fe10a643996e2ba81.html