InputStream readImageFromPath(String filePath)
            throws IOException {
        if (filePath.startsWith("http")) {
            URL url = null;
            HttpURLConnection conn;
            try {
                url = new URL(filePath);
                conn = (HttpURLConnection) url.openConnection();
                conn.setDoInput(true);
                conn.connect();
                InputStream inputStream = conn.getInputStream();
                return inputStream;
            } catch (MalformedURLException e) {
                e.printStackTrace();
            }
        } else {
            return new FileInputStream(new File(filePath));
        }
        return null;
    }

// BufferedImage bi = ImageIO.read(readImageFromPath(filePath));

/**
 * 图片缩放
 * 
 * @param filePath
 *            图片路径
 * @param height
 *            高度
 * @param width
 *            宽度
 * @param bb
 *            比例不对时是否需要补白
 */
BufferedImage resize2(String filePath, int height, int width, boolean bb) {
	try {
		double ratio = 0; // 缩放比例
		BufferedImage bi = ImageIO.read(readImageFromPath(filePath));
		Image itemp = bi.getScaledInstance(width, height,
				Image.SCALE_SMOOTH);
		// 计算比例
		if ((bi.getHeight() > height) || (bi.getWidth() > width)) {
			if (bi.getHeight() > bi.getWidth()) {
				ratio = (new Integer(height)).doubleValue()
						/ bi.getHeight();
			} else {
				ratio = (new Integer(width)).doubleValue() / bi.getWidth();
			}
			AffineTransformOp op = new AffineTransformOp(
					AffineTransform.getScaleInstance(ratio, ratio), null);
			itemp = op.filter(bi, null);
		}
		if (bb) {
			BufferedImage image = new BufferedImage(width, height,
					BufferedImage.TYPE_INT_RGB);
			Graphics2D g = image.createGraphics();
			g.setColor(Color.white);
			g.fillRect(0, 0, width, height);
			if (width == itemp.getWidth(null))
				g.drawImage(itemp, 0, (height - itemp.getHeight(null)) / 2,
						itemp.getWidth(null), itemp.getHeight(null),
						Color.white, null);
			else
				g.drawImage(itemp, (width - itemp.getWidth(null)) / 2, 0,
						itemp.getWidth(null), itemp.getHeight(null),
						Color.white, null);
			g.dispose();
			itemp = image;
		}
		return (BufferedImage) itemp;
	} catch (IOException e) {
		e.printStackTrace();
	}
	return null;
}

class ImageElement {
    int left;
	int top;
	BufferedImage bufferedImage;
}

/**
 * 最多行列数
 */
private int MAX_GRIDS = 3;
/**
 * 行间距
 */
private int spacing = 5;
/**
 * 边距
 */
private int border = 10;

/**
 * 图片的目标大小
 */
private int width = 200;

private ImageCombinationUtil() {
}

/**
 * 生成组合头像
 * 
 * @param paths
 *            用户图像
 * @throws IOException
 */
public void getCombinationOfhead(List<String> paths) throws IOException {
	int pathSize = paths.size();
	if (pathSize == 0) {
		return;
	}
	final int maxImageCount = MAX_GRIDS * MAX_GRIDS;
	int imageCount = pathSize > maxImageCount ? maxImageCount : pathSize;
	int grids = (int) Math.ceil(Math.sqrt(imageCount));
	grids = grids > MAX_GRIDS ? MAX_GRIDS : grids;
	int hrow = imageCount / grids;
	int rows = hrow + (imageCount - hrow * grids > 0 ? 1 : 0);
	int columnCountOfLastRow = imageCount - (rows - 1) * grids;
	int columns = imageCount / rows;
	columns = imageCount - columns * rows > 0 ? columns + 1 : columns;
	System.out.println("imageCount :" + pathSize + "\t grids :" + grids
			+ "\trows:" + rows + "\t columns:" + columns
			+ "\t columnsOfLastRow:" + columnCountOfLastRow);

	int[] matrix = new int[rows];
	Arrays.fill(matrix, grids);
	matrix[0] = columnCountOfLastRow;

	// 计算每个图片的尺寸
	int imageMeasure = (width - 2 * border - (grids - 1)
			* spacing)
			/ grids;

	List<ImageElement> imageElements = new ArrayList<ImageElement>();
	for (int i = 0; i < imageCount; i++) {
		ImageElement imageMatrix = new ImageElement();
		imageMatrix.bufferedImage = ImageCombinationUtil.resize2(paths.get(i),
				imageMeasure, imageMeasure, true);
		imageElements.add(imageMatrix);
	}

	// 计算坐标
	int top = border;
	top = rows < grids ? top + (spacing + imageMeasure) * (grids - rows)
			/ 2 : top;
	int imageIndex = 0;
	for (int row = 0; row < matrix.length; row++) {
		int column = 0;
		int left = border;
		left = matrix[row] < grids ? left + (spacing + imageMeasure)
				* (grids - matrix[row])/2 : left;
		while (column < matrix[row]) {
			imageElements.get(imageIndex).left = left + column
					* (imageMeasure + spacing);
			imageElements.get(imageIndex).top = top + row
					* (imageMeasure + spacing);
			imageIndex++;
			column++;
		}
	}
	// 创建画板
	BufferedImage outImage1 = new BufferedImage(width,
			width, BufferedImage.TYPE_INT_RGB);
	// 生成画布
	Graphics g = outImage1.getGraphics();
	Graphics2D g2d = (Graphics2D) g;
	// 设置背景色
	g2d.setBackground(new Color(231, 231, 231));
	// 通过使用当前绘图表面的背景色进行填充来清除指定的矩形。
	g2d.clearRect(0, 0, width, width);
	// 绘制
	for (ImageElement imageElement : imageElements) {
		g2d.drawImage(imageElement.bufferedImage, imageElement.left,
				imageElement.top, null);
		// 需要改变颜色的话在这里绘上颜色。可能会用到AlphaComposite类
	}

	String outPath = "d:\\" + System.currentTimeMillis() + ".jpg";
	String format = "JPG";
	ImageIO.write(outImage1, format, new File(outPath));
}

InputStream image2InputStream(BufferedImage bufferedImage) {
	InputStream inputStream = null;
	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
	ImageOutputStream imageOutputStream = null;
	try {
		imageOutputStream = ImageIO.createImageOutputStream(outputStream);
		ImageIO.write(bufferedImage, "JPG", imageOutputStream);
		inputStream = new ByteArrayInputStream(outputStream.toByteArray());
	} catch (IOException e) {
		e.printStackTrace();
	}
	return inputStream;
}

String cn2Spell(String chinese) {
    if (chinese == null || chinese.equals("")) {
        return "";
    } else {
        StringBuffer pybf = new StringBuffer();
        char[] arr = chinese.toCharArray();
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > 128) {
                try {
                    String[] str = PinyinHelper.toHanyuPinyinStringArray(
                            arr[i], defaultFormat);
                    if (str == null || str.length == 0) {
                        break;
                    }
                    pybf.append(PinyinHelper.toHanyuPinyinStringArray(
                            arr[i], defaultFormat)[0]);
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    break;
                }
            } else {
                pybf.append(arr[i]);
            }
        }
        return pybf.toString();
    }
}

String[] aArray = new String[5];  
String[] bArray = {"a","b","c", "d", "e"};  
String[] cArray = new String[]{"a","b","c","d","e"};  

int[] intArray = { 1, 2, 3, 4, 5 };  
String intArrayString = Arrays.toString(intArray);  
// print directly will print reference value  
System.out.println(intArray);  
// [I@7150bd4d  
System.out.println(intArrayString);  
// [1, 2, 3, 4, 5]  

String[] stringArray = { "a", "b", "c", "d", "e" };  
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
System.out.println(arrayList);  
// [a, b, c, d, e]  

String[] stringArray = { "a", "b", "c", "d", "e" };  
boolean b = Arrays.asList(stringArray).contains("a");  
System.out.println(b);  
// true  

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] intArray2 = { 6, 7, 8, 9, 10 };  
// Apache Commons Lang library  
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);  

method(new String[]{"a", "b", "c", "d", "e"});  

// containing the provided list of elements  
// Apache common lang  
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");  
System.out.println(j);  
// a, b, c  

String[] stringArray = { "a", "b", "c", "d", "e" };  
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
String[] stringArr = new String[arrayList.size()];  
arrayList.toArray(stringArr);  
for (String s : stringArr)  
    System.out.println(s);  

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));  
System.out.println(set);  
//[d, e, b, c, a]  

int[] intArray = { 1, 2, 3, 4, 5 };  
ArrayUtils.reverse(intArray);  
System.out.println(Arrays.toString(intArray));  
//[5, 4, 3, 2, 1]  

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array  
System.out.println(Arrays.toString(removed));  

byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();  
for (byte t : bytes) {  
   System.out.format("0x%x ", t);  
} 

public interface BlockingQueue<E> extends Queue<E> {

    //将给定元素设置到队列中，如果设置成功返回true, 否则返回false。如果是往限定了长度的队列中设置值，推荐使用offer()方法。
    boolean add(E e);

    //将给定的元素设置到队列中，如果设置成功返回true, 否则返回false. e的值不能为空，否则抛出空指针异常。
    boolean offer(E e);

    //将元素设置到队列中，如果队列中没有多余的空间，该方法会一直阻塞，直到队列中有多余的空间。
    void put(E e) throws InterruptedException;

    //将给定元素在给定的时间内设置到队列中，如果设置成功返回true, 否则返回false.
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;

    //从队列中获取值，如果队列中没有值，线程会一直阻塞，直到队列中有值，并且该方法取得了该值。
    E take() throws InterruptedException;

    //在给定的时间里，从队列中获取值，时间到了直接调用普通的poll方法，为null则直接返回null。
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;

    //获取队列中剩余的空间。
    int remainingCapacity();

    //从队列中移除指定的值。
    boolean remove(Object o);

    //判断队列中是否拥有该值。
    public boolean contains(Object o);

    //将队列中值，全部移除，并发设置到给定的集合中。
    int drainTo(Collection<? super E> c);

    //指定最多数量限制将队列中值，全部移除，并发设置到给定的集合中。
    int drainTo(Collection<? super E> c, int maxElements);
}

package com.hsshy.beam.queue.jvm;


import com.hsshy.beam.queue.entity.SuccessKilled;

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

/**
 * 秒杀队列(固定长度为100)
 * @author 科帮网 By https://blog.52itstyle.com
 * 创建时间   2018年5月10日
 */
public class SeckillQueue {
     //队列大小
    static final int QUEUE_MAX_SIZE   = 100;
    /** 用于多线程间下单的队列 */
    static BlockingQueue<SuccessKilled> blockingQueue = new LinkedBlockingQueue<SuccessKilled>(QUEUE_MAX_SIZE);
    
    /**
     * 私有的默认构造子，保证外界无法直接实例化
     */
    private SeckillQueue(){};
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private  static SeckillQueue queue = new SeckillQueue();
    }
    //单例队列
    public static SeckillQueue getMailQueue(){
        return SingletonHolder.queue;
    }
    /**
     * 生产入队
     * @param kill
     * @throws InterruptedException
     * add(e) 队列未满时，返回true；队列满则抛出IllegalStateException(“Queue full”)异常——AbstractQueue 
     * put(e) 队列未满时，直接插入没有返回值；队列满时会阻塞等待，一直等到队列未满时再插入。
     * offer(e) 队列未满时，返回true；队列满时返回false。非阻塞立即返回。
     * offer(e, time, unit) 设定等待的时间，如果在指定时间内还不能往队列中插入数据则返回false，插入成功返回true。 
     */
    public  Boolean  produce(SuccessKilled kill) throws InterruptedException {
        return blockingQueue.offer(kill);
    }
    /**
     * 消费出队
     * poll() 获取并移除队首元素，在指定的时间内去轮询队列看有没有首元素有则返回，否者超时后返回null
     * take() 与带超时时间的poll类似不同在于take时候如果当前队列空了它会一直等待其他线程调用notEmpty.signal()才会被唤醒
     */
    public  SuccessKilled consume() throws InterruptedException {
        return blockingQueue.take();
    }
    // 获取队列大小
    public int size() {
        return blockingQueue.size();
    }
}

package com.hsshy.beam.queue.jvm;

import com.hsshy.beam.queue.entity.SuccessKilled;
import com.hsshy.beam.queue.service.ISeckillService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * 消费秒杀队列
 * 创建者 科帮网
 * 创建时间 2018年4月3日
 */
@Component
public class TaskRunner implements ApplicationRunner {
    
    @Autowired
    private ISeckillService seckillService;
    
    @Override
    public void run(ApplicationArguments var) throws Exception{
        while(true){
            //进程内队列
            SuccessKilled kill = SeckillQueue.getMailQueue().consume();
            if(kill!=null){
                seckillService.startSeckil(kill.getId(), kill.getUserId());
            }
        }
    }
}

@ApiOperation(value="秒杀柒(进程内队列)",nickname="科帮网")
   @PostMapping("/startQueue")
   public R startQueue(long seckillId){
       seckillService.deleteSeckill(seckillId);
       final long killId =  seckillId;
       LOGGER.info("开始秒杀柒(正常)");
       for(int i=0;i<1000;i++){
           final long userId = i;
           Runnable task = new Runnable() {
               @Override
               public void run() {
                   SuccessKilled kill = new SuccessKilled();
                   kill.setId(killId);
                   kill.setUserId(userId);
                   try {
                       Boolean flag = SeckillQueue.getMailQueue().produce(kill);
                       if(flag){
                           LOGGER.info("用户:{}{}",kill.getUserId(),"秒杀成功");
                       }else{
                           LOGGER.info("用户:{}{}",userId,"秒杀失败");
                       }
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                       LOGGER.info("用户:{}{}",userId,"秒杀失败");
                   }
               }
           };
           executor.execute(task);
       }
       try {
           Thread.sleep(10000);
           Long  seckillCount = seckillService.getSeckillCount(seckillId);
           LOGGER.info("一共秒杀出{}件商品",seckillCount);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return R.ok();
   }

package com.hsshy.beam.queue.delay;
  
import java.util.concurrent.Delayed;  
import java.util.concurrent.TimeUnit;  
  
/** 
 * 消息体定义 实现Delayed接口就是实现两个方法即compareTo 和 getDelay最重要的就是getDelay方法，这个方法用来判断是否到期…… 
 *  
 */  
public class Message implements Delayed {  
    private int id;  
    private String body; // 消息内容  
    private long excuteTime;// 延迟时长，这个是必须的属性因为要按照这个判断延时时长。  
  
    public int getId() {  
        return id;  
    }  
  
    public String getBody() {  
        return body;  
    }  
  
    public long getExcuteTime() {  
        return excuteTime;  
    }  
  
    public Message(int id, String body, long delayTime) {  
        this.id = id;  
        this.body = body;  
        this.excuteTime = TimeUnit.NANOSECONDS.convert(delayTime, TimeUnit.MILLISECONDS) + System.nanoTime();  
    }  
  
    // 自定义实现比较方法返回 1 0 -1三个参数  
    @Override  
    public int compareTo(Delayed delayed) {  
        Message msg = (Message) delayed;  
        return Integer.valueOf(this.id) > Integer.valueOf(msg.id) ? 1  
                : (Integer.valueOf(this.id) < Integer.valueOf(msg.id) ? -1 : 0);  
    }  
  
    // 延迟任务是否到时就是按照这个方法判断如果返回的是负数则说明到期否则还没到期  
    @Override  
    public long getDelay(TimeUnit unit) {  
        return unit.convert(this.excuteTime - System.nanoTime(), TimeUnit.NANOSECONDS);  
    }  
}

package com.hsshy.beam.queue.delay;
  
import java.util.concurrent.DelayQueue;  
  
public class Consumer implements Runnable {  
    // 延时队列 ,消费者从其中获取消息进行消费  
    private DelayQueue<Message> queue;  
  
    public Consumer(DelayQueue<Message> queue) {  
        this.queue = queue;  
    }  
  
    @Override  
    public void run() {  
        while (true) {  
            try {  
                Message take = queue.take();  
                System.out.println("消费消息id：" + take.getId() + " 消息体：" + take.getBody());  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

package com.hsshy.beam.queue.delay;
  
import java.util.concurrent.DelayQueue;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class DelayQueueTest {  
     public static void main(String[] args) {    
            // 创建延时队列    
            DelayQueue<Message> queue = new DelayQueue<Message>();    
            // 添加延时消息,m1 延时3s    
            Message m1 = new Message(1, "world", 3000);    
            // 添加延时消息,m2 延时10s    
            Message m2 = new Message(2, "hello", 10000);    
            //将延时消息放到延时队列中  
            queue.offer(m2);    
            queue.offer(m1);    
            // 启动消费线程 消费添加到延时队列中的消息，前提是任务到了延期时间   
            ExecutorService exec = Executors.newFixedThreadPool(1);  
            exec.execute(new Consumer(queue));  
            exec.shutdown();  
        }    
}

int available()
     返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。
FileDescriptor 	getFD()
     返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，
     该文件系统正被此 FileInputStream 使用。
long 	skip(long n)
     从输入流中跳过并丢弃 n 个字节的数据。

int  available()
          返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。

public void write(byte[] b,
                  int off,
                  int len)
           throws IOException

public void write(int b)
           throws IOException

DataOutputStream outputStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("abc.txt")));
outputStream.writeDouble(3.14159265358979);
outputStream.writeUTF("仅仅是测试");
outputStream.writeDouble(3.58979);
outputStream.writeUTF("不仅仅是测试");
outputStream.close();

DataInputStream inputStream = new DataInputStream(new BufferedInputStream(new FileInputStream("abc.txt")));
System.out.println(inputStream.readDouble());
System.out.println(inputStream.readUTF());
System.out.println(inputStream.readDouble());
System.out.println(inputStream.readUTF());
inputStream.close();

BufferedReader in
   = new BufferedReader(new FileReader("foo.in"));

String 	readLine()
	  读取一个文本行。
boolean ready()
	  判断此流是否已准备好被读取。

PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("foo.out")));

PrintWriter printWriter = new PrintWriter(new BufferedWriter(new FileWriter("abc.text")));
PrintWriter printWriter = new PrintWriter("abc.text"); //快捷方式

PrintWriter(File file)
  使用指定文件创建不具有自动行刷新的新 PrintWriter。
PrintWriter(File file, String csn)
  创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter。
PrintWriter(OutputStream out)
  根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush)
  通过现有的 OutputStream 创建新的 PrintWriter。
PrintWriter(String fileName)
  创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
PrintWriter(String fileName, String csn)
  创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out)
  创建不带自动行刷新的新 PrintWriter。
PrintWriter(Writer out, boolean autoFlush)
  创建新 PrintWriter。

PrintWriter 	append(char c)
PrintWriter 	append(CharSequence csq)
PrintWriter 	append(CharSequence csq, int start, int end)

void 	println() 通过写入行分隔符字符串终止当前行。

PrintWriter 	printf(Locale l, String format, Object... args)
PrintWriter 	printf(String format, Object... args)
PrintWriter 	format(Locale l, String format, Object... args)
        使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。
PrintWriter 	format(String format, Object... args)
        使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。
void 	write(char[] buf)
void 	write(char[] buf, int off, int len) 写入字符数组，字符数组的某一部分。
void 	write(int c)
void 	write(String s)
void 	write(String s, int off, int len)
        写入单个字符、字符串及字符串的一部分。

boolean 	checkError()
        如果流没有关闭，则刷新流且检查其错误状态。
protected  void 	setError()
                指示已发生错误。
protected  void 	clearError()
        清除此流的错误状态。

/**
 * 验证管道流
 * */

/**
 * 消息发送类
 * */
class Send implements Runnable{
   private PipedOutputStream out=null;
   public Send() {
       out = new PipedOutputStream();
    }
   public PipedOutputStream getOut(){
       return this.out;
    }
   public void run(){
       String message = "hello , Rollen";
       try{
           out.write(message.getBytes());
       }catch (Exception e) {
           e.printStackTrace();
       }try{
           out.close();
       }catch (Exception e) {
           e.printStackTrace();
       }
    }
}

/**
 * 接受消息类
 * */
class Recive implements Runnable{
   private PipedInputStream input=null;
   public Recive(){
       this.input=new PipedInputStream();
    }
   public PipedInputStream getInput(){
       return this.input;
    }
   public void run(){
       byte[] b=new byte[1000];
       int len=0;
       try{
           len=this.input.read(b);
       }catch (Exception e) {
           e.printStackTrace();
       }try{
           input.close();
       }catch (Exception e) {
           e.printStackTrace();
       }
       System.out.println("接受的内容为 "+(new String(b,0,len)));
    }
}
/**
 * 测试类
 * */
class hello{
   public static void main(String[] args) throws IOException {
       Send send=new Send();
       Recive recive=new Recive();
        try{
//管道连接
           send.getOut().connect(recive.getInput());
       }catch (Exception e) {
           e.printStackTrace();
       }
       new Thread(send).start();
       new Thread(recive).start();
    }
}