文章目录
1.ThreadLocal
ThreadLocal 线程局部变量
- threadlocal只对当前线程范围有效,比如下面例子,在第一个线程设置的值,第二个线程是使用不了的
public class TLDemo2 {
private static ThreadLocal<User> threadLocal = new ThreadLocal<>();
public static void main(String[] args) {
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (Exception e) {
e.printStackTrace();
}
threadLocal.set(new User());
System.out.println(threadLocal.get());
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
e.printStackTrace();
}
// threadLocal.set(new User());
// threadLocal.remove();
System.out.println(threadLocal.get());
}).start();
}
}
2.有10000张火车票,同时有10个窗口对外售票
- 请写一个模拟程序
public class SaleTicket {
private static List<Integer> list=new LinkedList<>();
static{
for(int i=0;i<1000;i++){
list.add(i);
}
}
public static void main(String[] args) {
for(int i=0;i<10;i++){
new Thread(()->{
while(true){
synchronized(list){
if(list.size()<=0){
break;
}
System.out.println("卖的票号"+list.remove(0));
}
}
}).start();
}
}
}
在JDK1.5以后,java里面提供了很多的并发容器,这里我们用的是一个queue,队列。
- 所谓队列其实就是一个容器,就是站成一对,不管票还是人都在里面排成一堆,队列有几种,有先进先出的,
- 还有两端的队列,还有就是栈,先进后出,先加进去的后出来。
- 这里用了一个concurrentlinkedqueue,并发的链表队列。线程里面调用了一个poll方法,
- 意思是往外面拿一个数据,相当于在尾巴里面拿一个,如果没有拿到,他的返回值就是空,那么就中断线程。
- 这里面没有加锁,同样有判断,但是不会出问题。完成卖票功能这种效率是比较高的。queue里面是不能装空值。
- 这里虽然判断和操作是一起的,但是我们没有在判断里面有任何操作,大不了反过头来再拿一边,
- poll底层实现是cas,这里我们就不用加锁了。
public class SaleTicket {
private static Queue<Integer> list=new ConcurrentLinkedQueue<>();
static{
for(int i=0;i<1000;i++){
list.add(i);
}
}
public static void main(String[] args) {
for(int i=0;i<10;i++){
new Thread(()->{
while(true){
synchronized(list){
Integer ticket=list.poll();
if(ticket==null){
break;
}
System.out.println("卖的票号"+ticket);
}
}
}).start();
}
}
}
3.CopyOnWriteList 写时复制容器
在往集合中添加数据的时候,先拷贝存储的数组,然后添加元素到拷贝好的数组中,
- 然后用现在的数组去替换成员变量的数组(就是get等读取操作读取的数组)。
- 这个机制和读写锁是一样的,但是比读写锁有改进的地方,那就是读取的时候可以写入的 ,
- 这样省去了读写之间的竞争,看了这个过程,你也发现了问题,同时写入的时候怎么办呢,当然果断还是加锁。
- 读多写少可以用copyonwritelist
public class Demo {
public static void main(String[] args) {
// List<String> lists = new ArrayList<>();
// List<String> lists = new Vector<>();
List<String> lists = new CopyOnWriteArrayList<>();
Random r = new Random();
Thread[] threads = new Thread[100];
for (int i = 0; i < threads.length; i++) {
Runnable task = new Runnable() {
@Override
public void run() {
for (int j = 0; j < 1000; j++) {
lists.add("A" + r.nextInt(10000));
}
}
};
threads[i] = new Thread(task);
}
run(threads);
System.out.println(lists.size());
}
private static void run(Thread[] threads) {
long start = System.currentTimeMillis();
Arrays.asList(threads).forEach(t->t.start());
Arrays.asList(threads).forEach(t->{
try {
t.join();
} catch (Exception e) {
e.printStackTrace();
}
});
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
4.Collections
collections是java里面一个集合处理类,里面有给容器加锁的方法,通过调用api可以返回一个加了锁的容器。
ArrayList<String> arrayList = new ArrayList<>();
List<String> synchronizedList = Collections.synchronizedList(arrayList);
5.Queue
public static void main(String[] args) {
Queue<String> strings = new ConcurrentLinkedQueue<>();
for (int i = 0; i < 10; i++) {
//offer,类似于add方法,add会出一些问题,比如容量限制,
//超出限制会抛异常,offer有返回值可以判断是否加成功了
strings.offer("a" + i);
}
System.out.println(strings);
System.out.println(strings.size());
System.out.println(strings.poll());//拿了就没了
System.out.println(strings.size());
System.out.println(strings);
System.out.println(strings.peek());//用一下不删
System.out.println(strings.size());
}
}
6.ConcurrentHashMap
并发的hashmap,这个例子测试一下效率
*
- 第一种用hashtable,hashtable所有方法都加了锁了,第二种concurrenthashmap,
- 大致能看出来他的效率要比hashtable要高一些,在多线程的情况下。
- 为什么呢,因为hashtable往里面加任何数据的时候都是要锁定整个对象,
- 而concurrenthashmap,是分成十六个段,每次插数据的时候,只会锁住一小段,1.8之后实现不同。
public static void main(String[] args) {
// Map<String, String> map = new ConcurrentHashMap<>();
Map<String, String> map = new ConcurrentSkipListMap<>();
// Map<String, String> map = new Hashtable<>();
// Map<String, String> map = new HashMap<>();
// Map<String, String> map1 = Collections.synchronizedMap(map);
Random random = new Random();
Thread[] threads = new Thread[100];
CountDownLatch latch = new CountDownLatch(threads.length);
long start_time = System.currentTimeMillis();
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for(int j=0; j<10000;j++) {
map.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
// map1.put("a" + random.nextInt(100000), "a" + random.nextInt(100000));
}
latch.countDown();
});
}
Arrays.asList(threads).forEach(t->t.start());
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
long end_time = System.currentTimeMillis();
System.out.println(end_time-start_time);
}
7.LinkedBlockingQueue
阻塞式的容器
public class Demo {
private static BlockingQueue<String> strings = new LinkedBlockingQueue<>(10);
public static void main(String[] args) {
new Thread(()->{
for (int i = 0; i < 100; i++) {
try {
// 在阻塞式容器里面加了一个方法,put,也就是如果满了就会等待,对应的方法叫take,如果空了就会等待。
// 这种容器我们去用的时候自动就实现了阻塞式的生产者消费者。
strings.put("商品" + i);
System.out.println(Thread.currentThread().getName()+" put "+"商品"+i);
} catch (Exception e) {
e.printStackTrace();
}
}
}, "producer").start();
for (int i = 0; i < 5; i++) {
new Thread(()->{
for(;;){
try {
// take,拿,如果空了也会阻塞
System.out.println(Thread.currentThread().getName() + " take " + strings.take()); //如果空了,就会等待
} catch (Exception e) {
e.printStackTrace();
}
}
},"consumer" + i).start();
}
}
}
8.ArrayBlockingQueue
有界队列,意思就是说这个队列能装的元素的个数是固定的,后面讲线程池的时候,里面装的其实是一个个任务。
- 这里只能装10个,如果超过了可能会出问题可能会阻塞,这里看你调用什么方法。
- add会报异常
- offer不会报异常,他只通过布尔类型的返回值来告诉你是加成功了还是没有加成功。
- offer可以设置时间,如果这段时间加不进去就不加了也就是返回false
- put方法是满了会阻塞住。
public class Demo {
private static BlockingQueue<String> strings = new ArrayBlockingQueue<>(10);
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
strings.put("a" + i);
}
strings.add("aaaa");
// strings.put("aaaa");
// strings.offer("aaaa");
strings.offer("aaaa",1, TimeUnit.SECONDS);
System.out.println(strings);
}
}
9. DelayQueue
容器里每一个元素都设置了一个时间,时间到了才能从中提取元素
public class Demo {
private static BlockingQueue<MyTask> tasks = new DelayQueue<>();
static class MyTask implements Delayed{
long runningTime;
public MyTask(long rt) {
this.runningTime = rt;
}
@Override
public int compareTo(Delayed o) {
if (this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MICROSECONDS)) {
return -1;
}else if (this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS)) {
return 1;
}else {
return 0;
}
}
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
@Override
public String toString() {
return "" + runningTime;
}
public static void main(String[] args) throws InterruptedException {
long now = System.currentTimeMillis();
MyTask t1 = new MyTask(now+1000);
MyTask t2 = new MyTask(now+2000);
MyTask t3 = new MyTask(now+1500);
MyTask t4 = new MyTask(now+2500);
MyTask t5 = new MyTask(now+500);
tasks.put(t1);
tasks.put(t2);
tasks.put(t3);
tasks.put(t4);
tasks.put(t5);
System.out.println(tasks);
for (int i = 0; i < 5; i++) {
System.out.println(tasks.take());
}
}
}
}
10.TransferQueue
- 和普通的queue的方法差不多,多了一个transfer方法。
- 如果你用这种队列的话,往往是消费者先启动,生产者生产一个东西的时候,他先是去找消费者,
- 如果有消费者就直接丢给消费者。
public static void main(String[] args) throws InterruptedException {
LinkedTransferQueue<String> strings = new LinkedTransferQueue<>();
new Thread(()->{
try {
System.out.println("t1"+strings.take());
} catch (Exception e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
System.out.println("t2"+strings.take());
} catch (Exception e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(2);
strings.transfer("aaa");
// strings.put("aaa");
System.out.println(strings.size());
// new Thread(()->{
// try {
// System.out.println(strings.take());
// } catch (Exception e) {
// e.printStackTrace();
// }
// }).start();
}
11.SynchronizedQueue 同步队列
- 同步队列是容量为0,也就是来的东西必须给消费掉.
- 首先启动一个消费者,调用add方法,他报错了
- 只能调用put,意思就是阻塞等待消费者消费。put里面其实用的是transfer,任何东西必须消费,不能往容器里面扔
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> strings = new SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(strings.take());
} catch (Exception e) {
e.printStackTrace();
}
}).start();
//strings.add("aaa");
strings.put("aaa");
//strings.put("aac");
// strings.put("aaa");
// strings.put("aaa");
// strings.put("aaa");
System.out.println(strings.size());
}