持而盈
持而盈

java并发编程

简介

几年前在网上看了些资料,系统的梳理了下java并发编程,部分代码抄自网络.

synchronized 同步锁

锁竞争原理

syncchronized 关键字修饰方法,代码块. 为对象加锁. 需要注意:

  • 多个线程访问一个对象,竞争一把锁,没有得到锁的,会一直尝试竞争锁, 这里有个锁竞争问题.
  • 这是一把对象锁, 一个对象一把锁,多个对象他们有自己的锁,互不相关. 多个线程访问多个对象,锁 互不相关.
  • 这把对象锁是对象唯一的, 会锁住所有 synchronized 方法或代码块.

脏读

产生原因:
对于A对象的p属性: p属性有setter和getter方法
如果某线程正在setter,可能需要花费时间.而此时其他线程读取了属性,就存在脏读.

解决方法:
setter getter同时加锁.
只有设置完毕,才可以取值.

volatil 关键字

用于修饰变量,让该变量在多个线程之间可见.

从JDK1.5以后为了提升多线程运行效率,多线程会从从内存中拷贝一份变量,放进自己的内存区中,即线程内存和主内存是隔离的.这会造成问题:
在线程执行过程中,主内存中的变量改变,线程却无法感知.
volatil 修饰变量后,当主内存变量改变,线程会读取并同步到线程内存中.

线程通信

wait/notify

使用方法:

  • 必须在synchronized中使用,才有意义.
  • wait会阻塞当前线程并且释放锁.
  • notify会唤醒被wait阻塞的线程,但不释放锁. 也就是说被唤醒的线程若不能得到锁,依然不能执行.

下面是一个多线程队列代码:
队列数量固定,若写满,则put()阻塞.
若取尽,则get()阻塞

package com.bjsxt.base.conn009;

import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 模拟Queue
 * @author alienware
 *
 */
public class MyQueue {

    private final LinkedList list = new LinkedList();
    
    private final AtomicInteger count = new AtomicInteger(0);
    
    private final int maxSize;
    private final int minSize = 0;
    
    private final Object lock = new Object();
    
    public MyQueue (int maxSize){
        this.maxSize = maxSize;
    }

    public void put (Object obj) {
        synchronized(lock){
            while(count.get() == maxSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(obj);
            count.getAndIncrement();
            System.out.println(" 元素 " + obj + " 被添加 ");
            lock.notify();
            
        }
    }
    
    public Object take(){
        Object temp = null;
        synchronized (lock) {
            while(count.get() == minSize){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            count.getAndDecrement();
            temp = list.removeFirst();
            System.out.println(" 元素 " + temp + " 被消费 ");
            lock.notify();
        }
        return temp;
    }
    
    public int size(){
        return count.get();
    }
    
    
    public static void main(String[] args) throws Exception {
        
        final MyQueue m = new MyQueue(5);
        m.put("a");
        m.put("b");
        m.put("c");
        m.put("d");
        m.put("e");
        System.out.println("当前元素个数：" + m.size());
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m.put("h");
                m.put("i");
            }
        }, "t1");
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    Object t1 = m.take();
                    //System.out.println("被取走的元素为：" + t1);
                    Thread.sleep(1000);
                    Object t2 = m.take();
                    //System.out.println("被取走的元素为：" + t2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");

        t1.start();
        Thread.sleep(1000);
        t2.start();
        
    }
    
    
    
}

 
 
ThreadLocal 线程局部变量
 
 
概念:
 线程局部变量,ThreadLocal完全不提供锁,而是用空间换时间的手段,为每一个线程提供变量的独立副本,以保障线程安全.
 在一定情况下,使用ThreadLocal可以减少锁竞争.
 
 
一个例子:
 
 
package com.bjsxt.base.conn010;

public class ConnThreadLocal {

    public static ThreadLocal th = new ThreadLocal();
    
    public void setTh(String value){
        th.set(value);
    }
    public void getTh(){
        System.out.println(Thread.currentThread().getName() + ":" + this.th.get());
    }
    
    public static void main(String[] args) throws InterruptedException {
        
        final ConnThreadLocal ct = new ConnThreadLocal();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ct.setTh("张三");
                ct.getTh();
            }
        }, "t1");
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    ct.setTh("李四");
                    ct.getTh();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");
        
        t1.start();
        t2.start();
    }
    
}


 
 
单例 & 多线程
 
 
在多线程中,考虑到性能和线程安全,一般使用以下2种经典的单例模式
 
 
     
  
  • double check instance
    •  
  
  • static inner class
    •  
 
 
 
static inner class :
 
 
package com.bjsxt.base.conn011;

public class InnerSingleton {
    
    private static class Singletion {
        private static Singletion single = new Singletion();
    }
    
    public static Singletion getInstance(){
        return Singletion.single;
    }
    
}


 
 
double check instance:
 
 
package com.bjsxt.base.conn011;

public class DubbleSingleton {

    private static DubbleSingleton ds;
    
    public static DubbleSingleton getDs(){
        if(ds == null){
            try {
                //模拟初始化对象的准备时间...
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (DubbleSingleton.class) {
                //这里要再次检查非空,避免多线程同时创建多实例.
                if(ds == null){
                    ds = new DubbleSingleton();
                }
            }
        }
        return ds;
    }
    
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(DubbleSingleton.getDs().hashCode());
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(DubbleSingleton.getDs().hashCode());
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(DubbleSingleton.getDs().hashCode());
            }
        },"t3");
        
        t1.start();
        t2.start();
        t3.start();
    }
    
}


 
 
同步类容器
 
 
同步类容器都是线程安全的:
 古老的有: Vector, HashTable
 推荐使用: Collections.SynchronizedXXX
 
 
实现: 底层无非是用synchronized 关键字对每个公用方法进行同步.
 
 
缺陷: 每次只能一个线程操作容器,无法并发.
 
 
并发类容器
 
 
ConcurrentMap 此接口有2个重要的实现:
 ConcurrentHashMap
 ConcurrentSkipListMap (支持并发排序,弥补ConcurrentHashMap)
 
 
原理:
 ConcurrentHashMap内部使用段(Segment)来表示不同的部分,其实每个段就是一个小的HashTable,他们都有自己的锁.
 只要多个操作修改发生在不同的段上,他们就可以并发进行.
 把一个整体分成了16个段,也就是说最高可以支持16个线程并发修改操作.
 这是通过减小锁的粒度,从而降低竞争的一种方案.
 
 
package com.bjsxt.base.coll013;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class UseConcurrentMap {

    public static void main(String[] args) {
        ConcurrentHashMap chm = new ConcurrentHashMap();
        chm.put("k1", "v1");
        chm.put("k2", "v2");
        chm.put("k3", "v3");
        chm.putIfAbsent("k4", "vvvv");
        //System.out.println(chm.get("k2"));
        //System.out.println(chm.size());
        
        for(Map.Entry me : chm.entrySet()){
            System.out.println("key:" + me.getKey() + ",value:" + me.getValue());
        }
        
        
        
    }
}


 
 
Copy-On-Write容器
 
 
简称COW JDK中COW有2种:
 CopyOnWriteArrayList
 CopyOnWriteArraySet
 
 
原理:
 即写时复制,当我们往容器中添加一个元素时,不直接向容器添加,而是将原容器拷贝,复制一个新容器,然后修改新容器.
 修改完后,将元容器的引用指向新容器.
 这样做的好处是:可以对CopyOnWrite容器进行并发的读,而不需要加锁,因为当前容器不会添加任何元素.
 所以Copy-On-Write容器是一种读写分离的思想,读和写不同的容器.
 Copy-On-Write容器的写是有同步的.
 
 
package com.bjsxt.base.coll013;

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;

public class UseCopyOnWrite {

    public static void main(String[] args) {
        
        CopyOnWriteArrayList cwal = new CopyOnWriteArrayList();
        CopyOnWriteArraySet cwas = new CopyOnWriteArraySet();
        
        
    }
}


 
 
并发 Queue
 
 
java并发队列,主要分为2种:
 
 
     
  
  • ConcurrentLinkedQueue 非阻塞并发队列
    •  
  
  • BlockingQueue(这是个接口) 阻塞队列
    •  
 
 
 
ConcurrentLinkedQueue 非阻塞并发队列
 
 
这是一个高并发场景下的队列,通过无锁的方式,实现了高并发状态下的高性能.
 通常ConcurrentLinkedQueue 性能好于 BlockingQueue.
 它是一个基于链接节点的无界线程安全队列.
 遵循先进先出,就想排队一样.
 
 
重要方法:
 add() offer() 都是加入元素的方法,在本类中无区别.
 poll() peek() 都是取头元素节点,区别在于前者会删除元素,后者不会.
 
 
BlockingQueue 阻塞队列
 
 
主要有几种:
 
 
ArrayBlockingQueue 有界队列
 
 
基于数组的阻塞队列实现,在ArrayBlockingQueue内部维护了一个定长数组,以便缓存队列中的数据对象.
 其内部没有实现读写分离,也就意味着,生产也消费不能完全并行,长度是需要定义的.
 当队列写满时,所有写入者会被阻塞,直到能够写入.
 可以指定先进先出或者先进后出.
 也叫有界队列.
 
 
LinkedBlockingQueue 无界队列
 
 
基于链表的阻塞队列,同ArrayBlockingQueue类似,其内部也维持着一个数据缓冲队列(该队列由一个链表构成).
 LinkedBlockingQueue之所以能够高效的处理并发数据,是因为其内部采用分离锁(读写分离2个锁),从而实现生产和消费完全并行.
 这是一个无界队列
 
 
package com.bjsxt.base.coll013;

import java.util.concurrent.LinkedBlockingDeque;

public class UseDeque {

    public static void main(String[] args) {
        
        LinkedBlockingDeque dq = new LinkedBlockingDeque(10);
        dq.addFirst("a");
        dq.addFirst("b");
        dq.addFirst("c");
        dq.addFirst("d");
        dq.addFirst("e");
        dq.addLast("f");
        dq.addLast("g");
        dq.addLast("h");
        dq.addLast("i");
        dq.addLast("j");
        //dq.offerFirst("k");
        System.out.println("查看头元素：" + dq.peekFirst());
        System.out.println("获取尾元素：" + dq.pollLast());
        Object [] objs = dq.toArray();
        for (int i = 0; i < objs.length; i++) {
            System.out.println(objs[i]);
        }
        
    }
}


 
 
SynchronousQueue 无缓冲队列
 
 
没有缓冲的队列,生产者产生的数据会被消费者直接获取.
 类似于Go语言中的channel通信.
 在add() 之前必须有一个线程处于take() 状态,否则会报错.
 
 
ProrityBlockingQueue 基于优先级的阻塞队列
 
 
优先级判断依据:通过构造函数传入的Compator对象(即实现了Comparable接口的对象,通常都是队列数据本身).
 也就是说传入队列的对象必须实现Comparable接口.
 在实现ProrityBlockingQueue时,内部控制线程同步的锁是公平锁.
 他也是一个无界队列.
 
 
例子:
 
 
UsePriorityBlockingQueue.java 主程序
 
 
package com.bjsxt.base.coll013;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.PriorityBlockingQueue;

public class UsePriorityBlockingQueue {

    
    public static void main(String[] args) throws Exception{
        
        
        PriorityBlockingQueue q = new PriorityBlockingQueue();
        
        Task t1 = new Task();
        t1.setId(3);
        t1.setName("id为3");
        Task t2 = new Task();
        t2.setId(4);
        t2.setName("id为4");
        Task t3 = new Task();
        t3.setId(1);
        t3.setName("id为1");
        
        //return this.id > task.id ? 1 : 0;
        q.add(t1);  //3
        q.add(t2);  //4
        q.add(t3);  //1
        
        // 1 3 4
        System.out.println("容器：" + q);
        System.out.println(q.take().getId());
        System.out.println("容器：" + q);
//      System.out.println(q.take().getId());
//      System.out.println(q.take().getId());
        

        
    }
}


 
 
Task.java 任务类
 
 
package com.bjsxt.base.coll013;

public class Task implements Comparable{
    
    private int id ;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public int compareTo(Task task) {
        return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);  
    }
    
    public String toString(){
        return this.id + "," + this.name;
    }
    
}


 
 
DelayQueue 带有延迟时间的Queue
 
 
其中的元素只有当其指定的延迟时间到了,才能从队列中取出这个元素;
 DelayQueue中的元素必须实现Delayed接口;
 DelayQueue是一个没有大小限制的队列;
 应用场景包括:对缓存超时的数据进行处理,任务超时处理,空闲链接的关闭.
 
 
这有个很有趣的例子: 模拟网吧上机
 
 
WangBa.java 网吧主程序
 
 
package com.bjsxt.base.coll013;

import java.util.concurrent.DelayQueue;

public class WangBa implements Runnable {  
    
    private DelayQueue queue = new DelayQueue();  
    
    public boolean yinye =true;  
      
    public void shangji(String name,String id,int money){  
        Wangmin man = new Wangmin(name, id, 1000 * money + System.currentTimeMillis());  
        System.out.println("网名"+man.getName()+" 身份证"+man.getId()+"交钱"+money+"块,开始上机...");  
        this.queue.add(man);  
    }  
      
    public void xiaji(Wangmin man){  
        System.out.println("网名"+man.getName()+" 身份证"+man.getId()+"时间到下机...");  
    }  
  
    @Override  
    public void run() {  
        while(yinye){  
            try {  
                Wangmin man = queue.take();  
                xiaji(man);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
      
    public static void main(String args[]){  
        try{  
            System.out.println("网吧开始营业");  
            WangBa siyu = new WangBa();  
            Thread shangwang = new Thread(siyu);  
            shangwang.start();  
              
            siyu.shangji("路人甲", "123", 1);  
            siyu.shangji("路人乙", "234", 10);  
            siyu.shangji("路人丙", "345", 5);  
        }  
        catch(Exception e){  
            e.printStackTrace();
        }  
  
    }  
}  

 
 
Wangmin.java 网民
 
 

package com.bjsxt.base.coll013;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class Wangmin implements Delayed {  
    
    private String name;  
    //身份证  
    private String id;  
    //截止时间  
    private long endTime;  
    //定义时间工具类
    private TimeUnit timeUnit = TimeUnit.SECONDS;
      
    public Wangmin(String name,String id,long endTime){  
        this.name=name;  
        this.id=id;  
        this.endTime = endTime;  
    }  
      
    public String getName(){  
        return this.name;  
    }  
      
    public String getId(){  
        return this.id;  
    }  
      
    /** 
     * 用来判断是否到了截止时间 
     */  
    @Override  
    public long getDelay(TimeUnit unit) { 
        //return unit.convert(endTime, TimeUnit.MILLISECONDS) - unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        return endTime - System.currentTimeMillis();
    }  
  
    /** 
     * 相互比较排序用 
     */  
    @Override  
    public int compareTo(Delayed delayed) {  
        Wangmin w = (Wangmin)delayed;  
        return this.getDelay(this.timeUnit) - w.getDelay(this.timeUnit) > 0 ? 1:0;  
    }  
  
}  


 
 
并发编程设计模式
 
 
这些都是并发编程的设计模式.
 具体代码位置在:
 /home/zhangbing/virtualbox-shared/java_架构/并发编程代码/Multi_004
 
 
下面介绍这些模式的主要思想.
 
 
Future模式
 
 
主要实现方式是wait/notify原理.
 客户端获取数据时,服务端立即返回一个data,但是要调用Data.getRequest()才能得到真正的数据,然而此方法被加锁了.所以客户端此时被阻塞了.
 此时服务端立即开启线程去获取数据,待得到数据后,设置上去,再调用notify() 唤醒getRequest()方法.客户端便拿到了数据.
 
 
给出主要实现代码:
 
 
FutureData.java 加锁的逻辑都在这里
 
 
package com.bjsxt.height.design014;

public class FutureData implements Data{

    private RealData realData ;
    
    private boolean isReady = false;
    
    public synchronized void setRealData(RealData realData) {
        //如果已经装载完毕了，就直接返回
        if(isReady){
            return;
        }
        //如果没装载，进行装载真实对象
        this.realData = realData;
        isReady = true;
        //进行通知
        notify();
    }
    
    @Override
    public synchronized String getRequest() {
        //如果没装载好 程序就一直处于阻塞状态
        while(!isReady){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //装载好直接获取数据即可
        return this.realData.getRequest();
    }


}


 
 
Master-Worker模式
 
 
这种模式用于将众多的任务(或者一个庞大的任务拆分成众多小任务)分给数个的Worker去并发执行,以提升性能.
 
 
其核心点在于Master实例中要维护几个支持并发访问的集合,选对集合才是最重要的.
 主要代码如下:
 
 
Master.java 主要逻辑
 
 

package com.bjsxt.height.design015;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Master {

    //1 有一个盛放任务的容器, 这个是并发容器,不会阻塞.要注意判空.
    private ConcurrentLinkedQueue workQueue = new ConcurrentLinkedQueue();
    
    //2 需要有一个盛放worker的集合
    private HashMap workers = new HashMap();
    
    //3 需要有一个盛放每一个worker执行任务的结果集合
    private ConcurrentHashMap resultMap = new ConcurrentHashMap();
    
    //4 构造方法
    public Master(Worker worker , int workerCount){
        worker.setWorkQueue(this.workQueue);
        worker.setResultMap(this.resultMap);
        
        for(int i = 0; i < workerCount; i ++){
            this.workers.put(Integer.toString(i), new Thread(worker));
        }
        
    }
    
    //5 需要一个提交任务的方法
    public void submit(Task task){
        this.workQueue.add(task);
    }
    
    //6 需要有一个执行的方法，启动所有的worker方法去执行任务
    public void execute(){
        for(Map.Entry me : workers.entrySet()){
            me.getValue().start();
        }
    }

    //7 判断是否运行结束的方法
    public boolean isComplete() {
        for(Map.Entry me : workers.entrySet()){
            if(me.getValue().getState() != Thread.State.TERMINATED){
                return false;
            }
        }       
        return true;
    }

    //8 计算结果方法
    public int getResult() {
        int priceResult = 0;
        for(Map.Entry me : resultMap.entrySet()){
            priceResult += (Integer)me.getValue();
        }
        return priceResult;
    }
    
}


 
 
Worker.java 工作线程的实现
 
 
package com.bjsxt.height.design015;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Worker implements Runnable {

    private ConcurrentLinkedQueue workQueue;
    private ConcurrentHashMap resultMap;
    
    public void setWorkQueue(ConcurrentLinkedQueue workQueue) {
        this.workQueue = workQueue;
    }

    public void setResultMap(ConcurrentHashMap resultMap) {
        this.resultMap = resultMap;
    }
    
    @Override
    public void run() {
        while(true){
            Task input = this.workQueue.poll();
            if(input == null) break;
            Object output = handle(input);
            this.resultMap.put(Integer.toString(input.getId()), output);
        }
    }

    private Object handle(Task input) {
        Object output = null;
        try {
            //处理任务的耗时。。 比如说进行操作数据库。。。
            Thread.sleep(500);
            output = input.getPrice();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }



}


 
 
消费者-生产者模式
 
 
此模式的核心点:
 生产者和消费者要共享一个缓冲区(集合容器),他们一个放入,一个取出.
 这个缓冲区是个阻塞容器(BlockingQueue),当容器中没有元素(可能是生产者停止了)时,消费者会被阻塞.
 在主函数中创建这个容器,并实例化生产者和消费者,并将缓冲区的引用传给他们(通过构造函数).
 
 
主程序
 
 
package com.bjsxt.height.design016;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {

    public static void main(String[] args) throws Exception {
        //内存缓冲区
        BlockingQueue queue = new LinkedBlockingQueue(10);
        //生产者
        Provider p1 = new Provider(queue);
        
        Provider p2 = new Provider(queue);
        Provider p3 = new Provider(queue);
        //消费者
        Consumer c1 = new Consumer(queue);
        Consumer c2 = new Consumer(queue);
        Consumer c3 = new Consumer(queue);
        //创建线程池运行,这是一个缓存的线程池，可以创建无穷大的线程，没有任务的时候不创建线程。空闲线程存活时间为60s（默认值）

        ExecutorService cachePool = Executors.newCachedThreadPool();
        cachePool.execute(p1);
        cachePool.execute(p2);
        cachePool.execute(p3);
        cachePool.execute(c1);
        cachePool.execute(c2);
        cachePool.execute(c3);

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        p1.stop();
        p2.stop();
        p3.stop();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }       
//      cachePool.shutdown(); 
//      cachePool.shutdownNow();
        

    }
    
}


 
 
生产者
 
 
package com.bjsxt.height.design016;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Provider implements Runnable{
    
    //共享缓存区
    private BlockingQueue queue;
    //多线程间是否启动变量，有强制从主内存中刷新的功能。即时返回线程的状态
    private volatile boolean isRunning = true;
    //id生成器
    private static AtomicInteger count = new AtomicInteger();
    //随机对象
    private static Random r = new Random(); 
    
    public Provider(BlockingQueue queue){
        this.queue = queue;
    }

    @Override
    public void run() {
        while(isRunning){
            try {
                //随机休眠0 - 1000 毫秒 表示获取数据(产生数据的耗时) 
                Thread.sleep(r.nextInt(1000));
                //获取的数据进行累计...
                int id = count.incrementAndGet();
                //比如通过一个getData方法获取了
                Data data = new Data(Integer.toString(id), "数据" + id);
                System.out.println("当前线程:" + Thread.currentThread().getName() + ", 获取了数据，id为:" + id + ", 进行装载到公共缓冲区中...");
                if(!this.queue.offer(data, 2, TimeUnit.SECONDS)){
                    System.out.println("提交缓冲区数据失败....");
                    //do something... 比如重新提交
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void stop(){
        this.isRunning = false;
    }
    
}


 
 
消费者
 
 
package com.bjsxt.height.design016;

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class Consumer implements Runnable{

    private BlockingQueue queue;
    
    public Consumer(BlockingQueue queue){
        this.queue = queue;
    }
    
    //随机对象
    private static Random r = new Random(); 

    @Override
    public void run() {
        while(true){
            try {
                //获取数据
                Data data = this.queue.take();
                //进行数据处理。休眠0 - 1000毫秒模拟耗时
                Thread.sleep(r.nextInt(1000));
                System.out.println("当前消费线程：" + Thread.currentThread().getName() + "， 消费成功，消费数据为id: " + data.getId());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


 
 
Concurrent.util常用类
 
 
这些常用类可以帮助快速设计并发程序
 
 
CountDownLatch
 
 
常用于监听某个初始化操作,等初始化执行完毕后,通知主线程继续工作.
 
 
注意点:
 阻塞的是调用 awaite()方法的线程.
 等待countDown()次数达到后,阻塞的线程才继续.
 
 
package com.bjsxt.height.concurrent019;

import java.util.concurrent.CountDownLatch;

public class UseCountDownLatch {

    public static void main(String[] args) {
        
        final CountDownLatch countDown = new CountDownLatch(2);
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("进入线程t1" + "等待其他线程处理完成...");
                    countDown.await();
                    System.out.println("t1线程继续执行...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1");
        
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t2线程进行初始化操作...");
                    Thread.sleep(3000);
                    System.out.println("t2线程初始化完毕，通知t1线程继续...");
                    countDown.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("t3线程进行初始化操作...");
                    Thread.sleep(4000);
                    System.out.println("t3线程初始化完毕，通知t1线程继续...");
                    countDown.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        t1.start();
        t2.start();
        t3.start();
        
        
        
    }
}


 
 
CyclicBarrier
 
 
假设一个场景:
 每个线程代表一个跑步的运动员,所有运动员站在起跑线等,
 等所有人都准备好,才一起跑.
 
 
package com.bjsxt.height.concurrent019;
import java.io.IOException;  
import java.util.Random;  
import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors; 
public class UseCyclicBarrier {

    static class Runner implements Runnable {  
        private CyclicBarrier barrier;  
        private String name;  
        
        public Runner(CyclicBarrier barrier, String name) {  
            this.barrier = barrier;  
            this.name = name;  
        }  
        @Override  
        public void run() {  
            try {  
                Thread.sleep(1000 * (new Random()).nextInt(5));  
                System.out.println(name + " 准备OK.");  
                barrier.await();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (BrokenBarrierException e) {  
                e.printStackTrace();  
            }  
            System.out.println(name + " Go!!");  
        }  
    } 
    
    public static void main(String[] args) throws IOException, InterruptedException {  
        CyclicBarrier barrier = new CyclicBarrier(3);  // 3 
        ExecutorService executor = Executors.newFixedThreadPool(3);  
        
        executor.submit(new Thread(new Runner(barrier, "zhangsan")));  
        executor.submit(new Thread(new Runner(barrier, "lisi")));  
        executor.submit(new Thread(new Runner(barrier, "wangwu")));  
  
        executor.shutdown();  
    }  
  
}  

 
 
Executor 线程池
 
 
常用线程池
 
 
java.util.concurrent.Executors 是一个线程池框架,可以创建以下几种线程池:
 
 
newFixedThreadPool() 返回固定大小的线程池,线程数始终不变,若线程池有空闲,则立即执行,若没有,则把任务缓存在队列中等待.
 newSingleThreadPool() 返回单个线程的线程池,其他同上.
 newCachedThreadPool() 可缓存的线程池,线程数可以根据任务量自动变化.
 newScheduledThreadPool() 固定长度的线程池,可以使用延迟或者定时来执行任务.
 
 
package com.bjsxt.height.concurrent017;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class UseExecutors {

    public static void main(String[] args) {
        
        ExecutorService pool = Executors.newScheduledThreadPool(10);
        
        //cache fixed single
        
        
        
    }
}


 
 
线程池底层创建方法
 
 
主函数
 
 
package com.bjsxt.height.concurrent018;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;



public class UseThreadPoolExecutor1 {


    public static void main(String[] args) {
        /**
         * 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
         * 若大于corePoolSize，则会将任务加入队列，
         * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
         * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
         * 
         */ 
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                1,              //核心线程数,线程池始终保有这些线程,当缓存没满时,也只用核心线程干活,不起多余线程.
                2,              //最大线程数,当缓存满了时,再来任务会起额外线程,但是绝不超过最大线程数.
                60,             //空闲线程回收时间.
                TimeUnit.SECONDS, //回收单位
                new ArrayBlockingQueue(3)         //指定一种队列 （有界队列）
                //new LinkedBlockingQueue()
                , new MyRejected()                          //指定拒绝策略,可自定义.
                //, new DiscardOldestPolicy()
                );
        
        MyTask mt1 = new MyTask(1, "任务1");
        MyTask mt2 = new MyTask(2, "任务2");
        MyTask mt3 = new MyTask(3, "任务3");
        MyTask mt4 = new MyTask(4, "任务4");
        MyTask mt5 = new MyTask(5, "任务5");
        MyTask mt6 = new MyTask(6, "任务6");
        
        pool.execute(mt1);
        pool.execute(mt2);
        pool.execute(mt3);
        pool.execute(mt4);
        pool.execute(mt5);
        pool.execute(mt6);
        
        pool.shutdown();
        
    }
}


 
 
自定义拒绝策略
 
 
package com.bjsxt.height.concurrent018;

import java.net.HttpURLConnection;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class MyRejected implements RejectedExecutionHandler{

    
    public MyRejected(){
    }
    
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("自定义处理..");
        System.out.println("当前被拒绝任务为：" + r.toString());
        

    }

}


 
 
Lock 使用JDK锁
 
 
ReentrantLock 重入锁
 
 
ReentrantLock和synchronized关键字差不多,只是用起来更灵活.
 
 
锁的notify/signal 方法是唤醒一个awaite线程,
 notifyAll/signalAll 唤醒所有 awaite线程.
 
 
使用重入锁
 
 
package com.bjsxt.height.lock020;

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UseReentrantLock {
    
    private Lock lock = new ReentrantLock();
    
    public void method1(){
        try {
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
            Thread.sleep(1000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            
            lock.unlock();
        }
    }
    
    public void method2(){
        try {
            lock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
            Thread.sleep(2000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {

        final UseReentrantLock ur = new UseReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ur.method1();
                ur.method2();
            }
        }, "t1");

        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //System.out.println(ur.lock.getQueueLength());
    }
    
    
}


 
 
使用Condition
 
 
Condition的功能与 synchronized 中的 awaite/notify 一样.
 
 
package com.bjsxt.height.lock020;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UseCondition {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public void method1(){
        try {
            lock.lock();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "进入等待状态..");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
            condition.await();  // Object wait
            System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void method2(){
        try {
            lock.lock();
            System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
            condition.signal();     //Object notify
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        
        final UseCondition uc = new UseCondition();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                uc.method1();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                uc.method2();
            }
        }, "t2");
        t1.start();

        t2.start();
    }
    
    
    
}


 
 
使用多Condition
 
 
一个锁可以申明多个Condition,更加灵活.
 
 
package com.bjsxt.height.lock020;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UseManyCondition {

    private ReentrantLock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    
    public void m1(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
            c1.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void m2(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
            c1.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void m3(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
            c2.await();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void m4(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
            c1.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public void m5(){
        try {
            lock.lock();
            System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    public static void main(String[] args) {
        
        
        final UseManyCondition umc = new UseManyCondition();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m2();
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m3();
            }
        },"t3");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m4();
            }
        },"t4");
        Thread t5 = new Thread(new Runnable() {
            @Override
            public void run() {
                umc.m5();
            }
        },"t5");
        
        t1.start(); // c1
        t2.start(); // c1
        t3.start(); // c2
        

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t4.start(); // c1
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t5.start(); // c2
        
    }
    
    
    
}


 
 
ReentrantReadWriteLock 读写锁
 
 
在高并发访问下,尤其是读多写少,性能极强,远高于重入锁.
 
 
其本质是读写分离的2把锁.
 在读锁下,多线程可以并发访问.
 在写锁下,只能顺序访问.
 
 
口诀:
 读读共享,读写互斥,写写互斥.
 
 
package com.bjsxt.height.lock021;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class UseReentrantReadWriteLock {

    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private ReadLock readLock = rwLock.readLock();
    private WriteLock writeLock = rwLock.writeLock();
    
    public void read(){
        try {
            readLock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
            Thread.sleep(3000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readLock.unlock();
        }
    }
    
    public void write(){
        try {
            writeLock.lock();
            System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
            Thread.sleep(3000);
            System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock();
        }
    }
    
    public static void main(String[] args) {
        
        final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
        
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                urrw.read();
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                urrw.read();
            }
        }, "t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                urrw.write();
            }
        }, "t3");
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                urrw.write();
            }
        }, "t4");       
        
//      t1.start();
//      t2.start();
        
//      t1.start(); // R 
//      t3.start(); // W
        
        t3.start();
        t4.start();
        
    }
}


 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java并发编程)

        

            

                
    
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • Java并发编程-AQS详解及案例实战（上篇）
                        猿与禅
Java技术栈源码分析javaAQS并发编程原理
                        
    文章目录AQS概述AQS的核心概念AQS的工作原理AQS的灵活性使用场景使用指南使用示例AQS的本质:为啥叫做异步队列同步器AQS的核心机制“异步队列”的含义“同步器”的含义总结加锁失败的时候如何借助AQS异步入队阻塞等待AQS的锁队列加锁失败时的处理流程异步入队的机制总结ReentractLock如何设置公平锁策略以及原理设置公平锁策略公平锁的运作原理尝试获取锁释放锁性能与公平性的权衡tryLo
    
                    
    • 
                    
  • Java并发编程：线程生命周期
                        乐只乐之
Java并发编程java职场和发展后端
                        
    Java并发编程专栏文章收录于Java并发编程专栏线程生命周期  线程是Java并发编程的核心概念，理解线程生命周期对于编写高效的并发程序至关重要。本文将详细介绍Java线程的六种状态以及状态之间的转换关系，帮助读者更好地理解线程的行为。  在Java中JVM将线程按照生命周期划分为了四大种类：运行、等待、阻塞和结束，其中运行分为就绪（READY）和运行中中（RUNNING），阻塞分为等待（WAI
    
                    
    • 
                    
  • SpringBoot高并发！java分布式开发面试题
                        spring面试题
程序员面试后端java
                        
    正文梳理知识点，是快速提升技术的关键前面讲过，快速提升自己的技术硬实力其实是有方法的。大致就是梳理知识点+夯实基础+进阶深入学习+实战，下面我会一点点跟大家剖析，本文干货满满，大家仔细阅读。梳理知识后，夯实基础乃是刚需：深入进阶学习（28个主流Java知识点“一网打尽”）1、并发编程Java并发编程是整个Java开发体系中最难以理解，但也是最重要的知识点之一，一旦掌握你一定在市场上供不应求。Jav
    
                    
    • 
                    
  • Java并发编程(五)—ReetrantLock详解及应用
                        echola_mendes
Java并发编程java开发语言
                        
    目录一、ReetrantLock的特性1、非阻塞获取锁2、带超时的锁获取:3、锁的公平性4、锁的可中断性5、Condition条件变量6、锁的可重入性可重入锁不可重入锁7、性能优化二、ReentrantLock和Synchronized的区别1、语法和使用方式2、锁的获取和释放3、高级特性4、条件变量5、性能总结三、ReentrantLock使用场景之前的文章Java并发编程(四)—synchro
    
                    
    • 
                    
  • Java修炼之道--并发编程
                        weixin_30312557
运维面试操作系统
                        
    原作地址：https://github.com/frank-lam/2019_campus_apply前言在本文将总结多线程并发编程中的常见面试题，主要核心线程生命周期、线程通信、并发包部分。主要分成“并发编程”和“面试指南”两部分，在面试指南中将讨论并发相关面经。参考资料：《Java并发编程实战》第一部分：并发编程1.线程状态转换新建（New）创建后尚未启动。可运行（Runnable）可能正在运
    
                    
    • 
                    
  • 深入理解 `ThreadLocal` 的 `set` 和 `get` 方法
                        CodeDunkster
javajvm开发语言
                        
    ThreadLocal类在Java并发编程中非常有用，它允许每个线程拥有自己独立的变量副本。本文将详细讲解ThreadLocal的set和get方法的工作原理，并通过示例代码说明线程如何使用多个ThreadLocal实例。ThreadLocal的set和get方法原理set方法ThreadLocal的set方法用于将值存储到当前线程的ThreadLocalMap中。其主要步骤如下：获取当前线程：s
    
                    
    • 
                    
  • Java 内存模型-锁的内存语义
                        markfork

                        
    章节目录锁的释放-获取建立的happens-before关系锁的释放-获取的内存语义锁的释放-获取建立的happens-before关系锁是Java并发编程中最重要的同步机制。锁除了让临界区互斥执行之外，还可以让释放锁的线程向获取同一个锁的线程发送消息。如下所示，下面是锁释放-锁获取的示例代码classMonitorExample{inta=0;publicsynchronizedvoidwrit
    
                    
    • 
                    
  • Java8 关于最佳线程数
                        没有颜色的菜

                        
    前言关于最佳线程数的设置，总是那么模糊，不知道该如何设置，偶然间在Java并发编程实践里看到了对他的定义：要使处理器达到期望的使用率，线程池的最佳大小等于：1695055395.jpg需要注意的是，我们需要制定一个CPU的利用率，如果是100%，那么线程数就取决于WaitTime/ComputeTime如果我们的任务是计算型任务，那么等待时间为零，那么线程数设置为CPU+1如果我们的任务是IO密集
    
                    
    • 
                    
  • Java并发编程的核心概念--线程与进程
                        纣王家子迎新
java开发语言学习线程与进程
                        
    ‌原子性‌：‌操作或多个操作要么全部执行且不被打断，‌要么都不执行。‌这保证了线程在执行操作时不会被其他线程干扰。‌‌可见性‌：‌当多个线程访问同一个变量时，‌一个线程修改了这个变量的值，‌其他线程能够立即看到修改的值。‌这通过volatile关键字、synchronized和Lock等机制实现。‌有序性‌：‌程序执行的顺序按照代码的先后顺序执行。‌Java内存模型允许指令重排序，但提供了vola
    
                    
    • 
                    
  • Java并发编程(四)—synchronized关键字的应用
                        echola_mendes
Java并发编程java开发语言
                        
    目录1、synchronized适用场景2、synchronized的原理3、synchronized的锁升级4、synchronized的注意事项5、总结synchronized是Java中用于实现线程同步的关键字。它可以在方法级别或代码块级别使用，以确保同一时刻只有一个线程可以访问被同步的代码段。synchronized通过内部锁机制来实现线程间的互斥访问synchronized关键字可以在方
    
                    
    • 
                    
  • Java笔试面试题之多线程常见考点总结
                        工程师老罗
Java笔试面试题AI答java开发语言
                        
    Java多线程面试题涵盖了Java多线程编程的多个重要方面，主要考察面试者对Java并发编程的理解和应用能力。以下是常见的考点总结：基本概念与区别：进程与线程的区别：进程是资源分配的基本单位，线程是CPU调度的基本单位，线程共享进程资源。Java堆与栈的区别：堆用于存储对象实例，栈用于存储局部变量和方法调用。线程创建与状态：线程创建方式：继承Thread类、实现Runnable接口、使用Calla
    
                    
    • 
                    
  • Java并发编程学习总结
                        Aries_Li

                        
    关于并发并发在开发中广泛的应用，非常的重要，最近在读《Java并发编程的艺术》艺术，希望写一些东西来记录和巩固。上下文切换、死锁上下文切换频繁的上下文切换不仅不能加快程序的运行，还会降低程序的性能。文中提到了一些方法减少上下文切换的方法：无锁并发编程通过将数据分段，使用不同线程处理不同的数据。CAS算法Java的Atomic包使用CAS算法来更新数据，而不需要加锁。使用最小线程避免创建不需要的线程
    
                    
    • 
                    
  • 架构面试题汇总：并发和锁（2024版）
                        码到三十五
面试攻关架构java面试
                        
    在现代软件开发中，并发编程和多线程处理已成为不可或缺的技能。Java作为一种广泛使用的编程语言，提供了丰富的并发和多线程工具，如锁、同步器、并发容器等。因此，对于Java开发者来说，掌握并发编程和多线程处理的知识至关重要。以下面试题涵盖了Java中的锁机制、并发工具类、内存模型、可见性、原子性、有序性等方面。通过这些问题，可以展示自己对Java并发编程的深入理解和实践经验。请注意，并发编程是一个复
    
                    
    • 
                    
  • Java并发编程：深入剖析ThreadLocal
                        「已注销」
多线程并发并发多线程
                        
    想必很多朋友对ThreadLocal并不陌生，今天我们就来一起探讨下ThreadLocal的使用方法和实现原理。首先，本文先谈一下对ThreadLocal的理解，然后根据ThreadLocal类的源码分析了其实现原理和使用需要注意的地方，最后给出了两个应用场景。以下是本文目录大纲：一.对ThreadLocal的理解二.深入解析ThreadLocal类三.ThreadLocal的应用场景若有不正之处
    
                    
    • 
                    
  • 【转】-Java并发编程：阻塞队列
                        booleandev
JUCJava转载
                        
    Java并发编程：阻塞队列该博客转载自**Matrix海子的Java并发编程：阻塞队列**Java并发编程：阻塞队列在前面几篇文章中，我们讨论了同步容器(Hashtable、Vector），也讨论了并发容器（ConcurrentHashMap、CopyOnWriteArrayList），这些工具都为我们编写多线程程序提供了很大的方便。今天我们来讨论另外一类容器：阻塞队列。在前面我们接触的队列都是非
    
                    
    • 
                    
  • 架构师之路--JAVA基础和多线程基础个别问题整理
                        shine_du
架构师之路多线程java队列
                        
    并发和锁（1）synchronized在JDK6做了哪些优化1.适应自旋锁：自旋锁：为了减少线程状态改变带来的消耗不停地执行当前线程2.锁消除：不可能存在共享数据竞争的锁进行消除3.锁粗化：将连续的加锁精简到只加一次锁4.轻量级锁：无竞争条件下通过CAS消除同步互斥5.偏向锁：无竞争条件下消除整个同步互斥，连CAS都不操作。Java并发编程：Lock转载http://www.cnblogs.com
    
                    
    • 
                    
  • 面试 Java 并发编程八股文十问十答第四期
                        程序员小白条
面试八股文系列面试java职场和发展八股文面试基础项目实战
                        
    面试Java并发编程八股文十问十答第四期作者：程序员小白条，个人博客相信看了本文后，对你的面试是有一定帮助的！关注专栏后就能收到持续更新！⭐点赞⭐收藏⭐不迷路！⭐1）线程优先级的理解线程优先级是操作系统调度线程时考虑的一个因素，用于确定线程在竞争CPU时间时的优先级顺序。Java中的线程优先级范围是从1到10，其中1是最低优先级，10是最高优先级。线程优先级的设置可以影响线程获取CPU时间片的概率
    
                    
    • 
                    
  • Java面试八股文
                        翁正存
java
                        
    1.网络一文搞懂所有计算机网络面试题-知乎01我应该站在谁的肩膀上-OSIvsTCPIP模型2.Java面渣逆袭必看，面试题八股文Java基础、Java集合框架、Java并发编程、JVM、Spring、Redis、MyBatis、MySQL、操作系统、计算机网络、RocketMQ、分布式、微服务|二哥的Java进阶之路3.算法代码随想录配套JetBrains刷题插件|labuladong的算法笔记
    
                    
    • 
                    
  • Scala基础教程--19--Actor
                        落空空。
javasparkscalajava开发语言
                        
    Scala基础教程–19–Actor章节目标了解Actor的相关概述掌握Actor发送和接收消息掌握WordCount案例1.Actor介绍Scala中的Actor并发编程模型可以用来开发比Java线程效率更高的并发程序。我们学习ScalaActor的目的主要是为后续学习Akka做准备。1.1Java并发编程的问题在Java并发编程中，每个对象都有一个逻辑监视器（monitor），可以用来控制对象
    
                    
    • 
                    
  • redo log —— MySQL宕机时数据不丢失的原理
                        天堂2013
MySQLMySQLredologjava
                        
    扫描下方二维码或者微信搜索公众号菜鸟飞呀飞，即可关注微信公众号，阅读更多Spring源码分析、Java并发编程和Netty源码系列文章。问题在开始阅读本文之前，可以先思考一下下面两个问题。众所周知，MySQL有四大特性：ACID，其中D指的是持久性（Durability），它的含义是MySQL的事务一旦提交，它对数据库的改变是永久性的，即数据不会丢失，那么MySQL究竟是如何实现的呢？MySQL数
    
                    
    • 
                    
  • Java多线程系列——内存模型JMM
                        飞影铠甲
Javajava开发语言c++算法
                        
    目录核心思想关键概念1.可见性2.原子性3.有序性工作原理并发工具类对并发编程的影响同步策略JMM的实践意义结语Java内存模型（JavaMemoryModel,JMM）是Java并发编程中的核心概念，其定义了Java虚拟机（JVM）在多线程环境中如何以及何时可以看到其他线程写入的变量值，以及如何同步访问共享变量。JMM解决了可见性、原子性、有序性这些在多线程编程中常见的问题。接下来，我们将详细探
    
                    
    • 
                    
  • JAVA并发编程之synchronized与Lock锁详解
                        一只经常emo的程序员
javajavadreamweaver开发语言
                        
    synchronized与Lock锁synchronized和ReentrantLock都是Java中提供的互斥锁。从功能上来说，你使用无论哪个，功能向都是一样的。today主要分析这两种锁他的实现逻辑。没把锁都聊两个维度的内容：加锁（排队等待）和释放锁wait¬ify、await&signal一、ReentrantLock锁特性要聊ReentrantLock，首先大家必须要知道AQS是什么
    
                    
    • 
                    
  • JAVA并发编程之ConcurrentHashMap详解
                        一只经常emo的程序员
javajava开发语言
                        
    ConcurrentHashMap一、ConcurrentHashMap写入数据流程一般在项目中使用ConcurrentHashMap时，都是作为JVM缓存使用的。ConcurrentHashMap是线程安全的。如果你项目涉及到了多个线程都会操作key-value结构时，别用HashMap，一定要上ConcurrentHashMap。在方法局部内，只有当前线程使用时，才可以用HashMap。Con
    
                    
    • 
                    
  • Java 并发编程之一——天生的多线程语言
                        君若雅
深入理解Java并发编程java后端
                        
    《Java并发编程》专栏旨在从头讲解Java并发编程的相关知识。为初学者和相关开发的同学提供一个由浅入深、由内到外的学习方向。如果文章中存在错误或者讲解不清楚的地方，欢迎大家互相讨论和指正！问题背景我相信，很多人都听说过一个结论：Java能够很好的支持并发编程，它是一个支持多线程的编程语言。那么，如果我们真的开始讨论起来并发编程，就会质疑这句话：真的如此吗？我简单的执行一个main函数，看打印出来
    
                    
    • 
                    
  • Java进阶之光！java向数据库添加中文乱码
                        编码老司机
程序员面试后端java
                        
    Java并发编程3、什么是多线程中的上下文切换?4、死锁与活锁的区别，死锁与饥饿的区别?5、Java中用到的线程调度算法是什么?6、什么是线程组，为什么在Java中不推荐使用?》7、为什么使用Executor框架?8、在Java中Executor和Executors的区别?9.如何在Windows和Linux上查找哪个线程使用的CPU时间最长?10、什么是原子操作?在JavaConcurrency
    
                    
    • 
                    
  • java并发编程（一）线程与进程
                        我犟不过你

                        
    一、进程进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。1.1进程切换进程从硬盘读取我们的程序代码，这个时候是比较费时的，CPU不会阻塞在这里等着，而是切
    
                    
    • 
                    
  • java并发编程的艺术
                        可爱的小小小狼
并发编程javaspring开发语言
                        
    java并发编程的艺术第一章–并发的挑战1。上下文切换上下文切换是由于多任务操作系统需要管理多个线程或进程的并发第二章—java并发机制的底层实现原理java代码编译成字节码，然后被类加载器加载到jvm中，jvm执行，最终转换为汇编指令在cpu上执行，java的并发机制依赖于jvm和cpu的指令。1.volatile的应用volatile加在共享变量上，保证所有线程看到这个变量的值是一致的，即va
    
                    
    • 
                    
  • Java并发编程基础
                        笨笨11

                        
    编写优质的并发代码是一件难度极高的事情。Java语言从第一版本开始内置了对多线程的支持，这一点在当年是非常了不起的，但是当我们对并发编程有了更深刻的认识和更多的实践后，实现并发编程就有了更多的方案和更好的选择。本文是对并发编程的一点总结和思考，同时也分享了Java5以后的版本中如何编写并发代码的一点点经验。为什么需要并发并发其实是一种解耦合的策略，它帮助我们把做什么（目标）和什么时候做（时机）分开
    
                    
    • 
                    
  • Java 并发编程之美：并发编程高级篇之一-chat
                        阿里加多

                        
    借用Java并发编程实践中的话：编写正确的程序并不容易，而编写正常的并发程序就更难了。相比于顺序执行的情况，多线程的线程安全问题是微妙而且出乎意料的，因为在没有进行适当同步的情况下多线程中各个操作的顺序是不可预期的。并发编程相比Java中其他知识点学习起来门槛相对较高，学习起来比较费劲，从而导致很多人望而却步；而无论是职场面试和高并发高流量的系统的实现却都还离不开并发编程，从而导致能够真正掌握并发
    
                    
    • 
                                
  • java Illegal overloaded getter method with ambiguous type for propert的解决
                                    zwllxs
javajdk
                                    
    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 
 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
    
                                
    • 
                                
  • IT人应当知道的10个行业小内幕
                                    beijingjava
工作互联网
                                    
    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。 
　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。 
　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
    
                                
    • 
                                
  • java 实现自定义链表
                                    CrazyMizzz
java数据结构
                                    
    1.链表结构 
 
  链表是链式的结构 
 
 
2.链表的组成 
 
   链表是由头节点，中间节点和尾节点组成 
 
   节点是由两个部分组成： 
 
      1.数据域 
      2.引用域 
 
 
3.链表的实现 
 
&nbs
    
                                
    • 
                                
  • web项目发布到服务器后图片过一会儿消失
                                    麦田的设计者
struts2上传图片永久保存
                                    
      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
    
                                
    • 
                                
  • CodeIgniter框架Cart类 name 不能设置中文的解决方法
                                    IT独行者
CodeIgniterCart框架　
                                    
    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下： 
$data = array(
               'id'      => 'sku_123ABC',
               'qty'     => 1,
               '
    
                                
    • 
                                
  • linux回收站
                                    _wy_
linux回收站
                                    
    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。      后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
    
                                
    • 
                                
  • jquery回到页面顶端
                                    知了ing
htmljquerycss
                                    
    html代码： 
 
<h1 id="anchor">页面标题</h1>
<div id="container">页面内容</div>
<p><a href="#anchor" class="topLink">回到顶端</a><
    
                                
    • 
                                
  • B树、B-树、B+树、B*树
                                    矮蛋蛋
B树
                                    
    原文地址： 
http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html 
B树 
 
       即二叉搜索树： 
 
       1.所有非叶子结点至多拥有两个儿子（Left和Right）； 
 
&nb
    
                                
    • 
                                
  • 数据库连接池
                                    alafqq
数据库连接池
                                    
    http://www.cnblogs.com/xdp-gacl/p/4002804.html 
 
@Anthor:孤傲苍狼 
 
数据库连接池 
 
用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： 
java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
    
                                
    • 
                                
  • java泛型
                                    百合不是茶
java泛型
                                    
    泛型 
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患 
  
泛型的特点：消除强制转换 确保类型安全 向后兼容 
  
简单泛型的定义： 
     泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 
class fan
    
                                
    • 
                                
  • javascript闭包[两个小测试例子]
                                    bijian1013
JavaScriptJavaScript
                                    
    一.程序一 
<script>
var name = "The Window";
var Object_a = {
　　name : "My Object",
　　getNameFunc : function(){
               var that = this;
　　　　return function(){
　　　　
    
                                
    • 
                                
  • 探索JUnit4扩展：假设机制（Assumption）
                                    bijian1013
javaAssumptionJUnit单元测试
                                    
    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
    
                                
    • 
                                
  • 【Gson四】范型POJO的反序列化
                                    bit1129
POJO
                                    
    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 
String str = new Gson().toJson(data); 
得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO 
  
import com.google.gson.Gson;

import java.
    
                                
    • 
                                
  • 【Spark八十五】Spark Streaming分析结果落地到MySQL
                                    bit1129
Stream
                                    
    几点总结： 
1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 
2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
    
                                
    • 
                                
  • NGINX + LUA实现复杂的控制
                                    ronin47
nginx lua
                                    
    安装lua_nginx_module 模块 
lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty 
Centos和debian的安装就简单了。。 
这里说下freebsd的安装： 
fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxvf lua-5.1.4.tar.gz
cd lua-5.1.4
ma
    
                                
    • 
                                
  • java-递归判断数组是否升序
                                    bylijinnan
java
                                    
    

public class IsAccendListRecursive {

	/*递归判断数组是否升序
	 * if a Integer array is ascending,return true
	 * use recursion
	 */
	
	public static void main(String[] args){
		IsAccendListRecursiv
    
                                
    • 
                                
  • Netty源码学习-DefaultChannelPipeline2
                                    bylijinnan
javanetty
                                    
    Netty3的API 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 
里面提到ChannelPipeline的一个“pitfall”： 
如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB） 
来
    
                                
    • 
                                
  • Java工具之JPS
                                    chinrui
java
                                    
    JPS使用 
  
  
熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
    
                                
    • 
                                
  • window.print分页打印
                                    ctrain
window
                                    
    
function init() {
    var tt = document.getElementById("tt");
    var childNodes = tt.childNodes[0].childNodes;
    var level = 0;
    for (var i = 0; i < childNodes.length; i++) {

    
                                
    • 
                                
  • 安装hadoop时 执行jps命令Error occurred during initialization of VM
                                    daizj
jdkhadoopjps
                                    
    在安装hadoop时，执行JPS出现下面错误 
  
[slave16][email protected]:/tmp/hsperfdata_hdfs# jps 
Error occurred during initialization of VM 
java.lang.Error: Properties init: Could not determine current working
    
                                
    • 
                                
  • PHP开发大型项目的一点经验
                                    dcj3sjt126com
PHP重构
                                    
    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
    
                                
    • 
                                
  • android笔记之--向网络发送GET/POST请求参数
                                    dcj3sjt126com
android
                                    
    使用GET方法发送请求 
private static boolean sendGETRequest (String path,

                     Map<String, String> params) throws Exception{

              //发送地http://192.168.100.91:8080/videoServi
    
                                
    • 
                                
  • linux复习笔记 之bash shell (3) 通配符
                                    eksliang
linux 通配符linux通配符
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2104387  
在bash的操作环境中有一个非常有用的功能，那就是通配符。 
下面列出一些常用的通配符，如下表所示    符号 意义   * 万用字符，代表0个到无穷个任意字符   ? 万用字符，代表一定有一个任意字符   [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
    
                                
    • 
                                
  • Android关于短信加密
                                    gqdy365
android
                                    
    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）： 
    1、因为Android有短信收发接口，可以调用接口完成短信收发； 
        发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
    
                                
    • 
                                
  • asp.net在网站根目录下创建文件夹
                                    hvt
.netC#hovertreeasp.netWeb Forms
                                    
    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： 
string m_keleyiFolderName = Server.MapPath("/hovertree");

if (Directory.Exists(m_keleyiFolderName))
{
//文件夹已经存在
return;
}
else
{
try
{
D
    
                                
    • 
                                
  • 一个合格的程序员应该读过哪些书
                                    justjavac
程序员书籍
                                    
    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ 
 
 “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 
 
很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
    
                                
    • 
                                
  • 单实例实践
                                    跑龙套_az
单例
                                    
      
 1、内部类 
public class Singleton {
      private static class SingletonHolder {
             public static Singleton singleton = new Singleton();
      } 
       public Singleton getRes
    
                                
    • 
                                
  • PO VO BEAN 理解
                                    q137681467
VODTOpo
                                    
    PO： 
     全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。 
  
  
BO： 
    全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
    
                                
    • 
                                
  • 战胜惰性，暗自努力
                                    金笛子
努力
                                    
    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？ 
我有个朋友是搞技术的，平时嘻嘻哈哈，以
    
                                
    • 
                                
  • NDK/JNI二维数组多维数组传递
                                    wenzongliang
二维数组jniNDK
                                    
    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 
Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata)

{
jint i,j;

int s
    
                                
    •