小超_8b2f
小超_8b2f

《JAVA并发编程实战》第五章 基础构建模块

5.1 同步容器类

5.1.1同步容器类的问题

在同步容器类中，复合操作在没有客户端加锁的的情况下仍然是线程安全的，
但当其他线程并发地修改容器时，可能有问题

程序清单5-1 Vector上可能导致混乱结果的复合操作
/**
 * 以下代码看似没问题：无论多少个线程同时调用，都不会破坏Vector
 * 但是从调用者的角度来讲情况就不同了。
 * 如果A线程在包含10个元素的Vector上调用getList
 * 同时B线程对同一个Vector调用removeLast,这些操作交替执行，
 * 则可能出现ArryIndexOutOfBoundsException异常
 */
public class Test01 {
    public static Object getLast(Vector list) {
        int lastIndex = list.size() -1;
        return list.get(lastIndex);
    }
    
    public static Object removeLast(Vector list) {
        int lastIndex = list.size() -1;
        return list.remove(lastIndex);
    }
}
 
 
程序清单5-2在使用客户端加锁的Vector上的复合操作
 
 
import java.util.Vector;

public class Test2 {
    public static Object getLast(Vector list) {//原子操作
        synchronized (list) {//保证Vector的大小在get和remove之间不会发生
            int lastIndex = list.size() -1;
            return list.get(lastIndex);
        }
    }
    
    public static Object removeLast(Vector list) { //原子操作
        synchronized (list) {//保证Vector的大小在get和remove之间不会发生
            int lastIndex = list.size() -1; 
            return list.remove(lastIndex);
        }
    }
}
 
 
程序清单5-3 可能抛出ArrayIndexOutOfBoundsException的迭代操作
 
 
//此处在循环，其他线程删除元素，会产生问题
for(int i = 0; i < vector.size(); i++) {
    doSomething(vector.get(i));
}

 
 
程序清单5-4 带有客户端加锁的迭代操作(解决不可靠迭代)
 
 
/**
在迭代期间持有Vector的锁，可以防止其他线程在迭代期间修改Vector，
然而这同样会导致其他线程在迭代期间无法访问它，因此降低了并发性
之所以要在客户端加锁（虽然Vector本身有内置锁，线程安全的）
是因为此处有复核操作：
【vector.size()  + vector.get(i)】且doSomthing()里面可能还对vector有修改
*/
synchronized(vector) {
    for(int i = 0; i < vector.size(); i++) 
      doSomething(vector.get(i));
}

 
 
 
  
迭代的标准方式是Iterator，然而有其他的线程并发地修改容器，
 即使是使用Iterator也无法避免在迭代期间对容器加锁。 在涉及同步容器类的迭代器时并没有考虑到并发修改的问题。并且他们的表现出的行为是“及时失败”（fail-fast）的。这意味着当他们发现容器在迭代过程中被修改时，就会抛出一个ConcurrentModificationException异常。这种“及时失效”并不是一种完备的处理机制，只是“善意地”捕获并发错误，因此只能作为并发问题的预警指示器。
 
 
 
 
`程序清单5-5 通过Iterator来迭代List
 
 
List widgetList = Collections.synchronizedList(new ArrayList());
...
/*javac将生产Iterator代码来循环，反复调用hasNext和next来迭代List对象,可能抛出ConcurrentModificationException
*/
for(Widget w : widgetList) 
    doSomething(w);

 
 
 
  
很多时候不希望加锁。例如：某些线程在可以访问容器之前，必须等待迭代过程结束，如果容器规模很大，或者每个元素上执行操作的时间很长，那么这些线程将长时间等待。容器像5-4那样加锁，可能会产生死锁。
 
 
 
 
 
  
如果不希望在迭代期间对容器加锁，那么一种替代方案是“克隆”容器，副本被封闭在线程内，并在副本上进行迭代。（容器大时有性能问题）
 
 
 
 
5.1.3 隐藏迭代
 
 
虽然加锁可以防止迭代器抛出ConcurrentModificationException，但必须在所有对共享容器进行迭代的地方都需要加锁。
 有些情况下，迭代器会隐藏起来。
 
 
public abstract class AbstractCollection implements Collection {
    public String toString() {
        Iterator it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {  //死循环
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }
}

 
 
程序清单 5-6 隐藏在字符串连接中的迭代操作（不要这么做）
 
 
@NotThreadSafe
public class HiddenIterator {
    
    @GuardedBy("this")
    private final Set set = new HashSet<>();
    
    public synchronized void add(Integer i) { set.add(i); }
    
    public synchronized void remove(Integer i) { set.remove(i);}
    
    /**
     * 可能会抛出ConcurrentModificationException，容器的toString()方法对容器进行了迭代
     * 真正的原因在于HiddenIterator不是线程安全的。在使用println中的set对象之前必须首先获取HiddenIterator的锁，
     * 但在调试代码的过程中通常会忽略这个问题
     */
    public void addTenThings() {
        Random r = new Random();
        for(int i = 0; i < 10; i++)
            add(r.nextInt());
        System.out.println("Debug: add ten elements to + " + set);
    }
}

 
 
5.2并发容器
 
 
5.2.1ConcurrentMap
 
 
程序清单5-7 ConcurrentMap 接口
 
 
public interface ConcurrentMap extends Map {
    //仅当K没有响应的映射值时才插入
     V putIfAbsent(K key, V value);

    //仅当K被映射到V时才移除
    boolean remove(Object key, Object value);

     //仅当K被映射到oldValue时才替换为newValue
     boolean replace(K key, V oldValue, V newValue);

      //仅当K被映射到某个值时才替换为newValue
      V replace(K key, V value);
}

 
 
5.3 阻塞队列和 生产者——消费者 模式
 
 
程序清单 5-8 桌面搜索应用程序中的生产者任务和消费者任务
 
 
/**
 * 生产者消费者提供了一直适合线程的方法将桌面搜索问题分解为更简单的组件。将文件的遍历与监理索引等功能分解为独立的操作，
 * 比将所有功能都放到一个操作中实现由着更高的代码可读性和可重用性：每个操作值完成一个任务，
 * 并且阻塞队列将负责所有的控制流，因此每个功能的代码都更加简单和清晰，并且可以并发执行，效率大于并行执行。
 * @param root
 * @throws InterruptedException
 */
package com.everjiankang.miaosha;

import java.io.File;
import java.io.FileFilter;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentSkipListSet;

/**
 * 文件爬虫程序（生产者）
 */
public class FileCrawer implements Runnable {

    private final BlockingQueue fileQueue;
    private final FileFilter fileFilter;
    private final File root;
    private final Set alreadyExistFileSet = new ConcurrentSkipListSet<>();
        
    public FileCrawer(BlockingQueue fileQueue, FileFilter fileFilter, File root) {
        super();
        this.fileQueue = fileQueue;
        this.fileFilter = fileFilter;
        this.root = root;
    }


    @Override
    public void run() {
        try {
            this.crawl(root);
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }
    
    
    private void crawl(File root) throws InterruptedException {
        if(root != null) {
            File[] entries = root.listFiles(fileFilter);
            if(entries != null) {
                for(File file : entries) {
                    if(file.isDirectory()) 
                        crawl(file);
                    else if(!alreadyIndexed(file)) {
                        System.out.println("生产者放入队列：" + file.getPath() + file.getName());
                        fileQueue.put(file);
                        alreadyExistFileSet.add(file.getPath()+file.getName());
                    }
                }
            } 
        }
    }
    
    private boolean alreadyIndexed(File file) {
        return alreadyExistFileSet.contains(file.getPath()+file.getName());
//        return fileQueue.contains(file);
    }

}

 
 
消费者
 
 
package com.everjiankang.miaosha;

import java.io.File;
import java.util.concurrent.BlockingQueue;

/**
 * 消费者，建立文件索引
 * @author guchunchao
 *
 */
public class Indexer implements Runnable {
    
    private final BlockingQueue queue;
    
    public Indexer(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while(true) {
                indexFile(queue.take());
            }
        } catch(InterruptedException e) {
            Thread.currentThread().interrupt();
        }

    }

    private void indexFile(File file) {
        System.out.println("消费：" + file.getPath()+file.getName());
    }

}

 
 
程序清单5-9 启动桌面搜索（生产者-消费者调用）
 
 
package com.everjiankang.miaosha;

import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class XiaoFeiQueue {
    private final static int BOUND = 10;
    private final static int N_CONSUMMERS = 10;

    public static void main(String[] args) {
        File file = new File("/Users/guchunchao/Desktop/深入理解java虚拟机视频1-6");
        File[] files = new File[10];
        files[0] = file;
        startIndexing(files);

    }
    
    public static void startIndexing(File[] files) {
        BlockingQueue queue = new LinkedBlockingDeque(BOUND);
        FileFilter filter = new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return true;
            }
        };
        
        //n个线程爬取文件
        for(File file : files) {
            new Thread(new FileCrawer(queue, filter, file)).start();
        }
        
        //10个线程消费
        for(int i = 0; i < N_CONSUMMERS; i++) {
            new Thread(new Indexer(queue)).start();
        }
    }

}

 
 
5.3.2 串行线程封闭
 
 
5.3.3 双端队列与工作密取
 
 
5.4 阻塞方法与中断方法
 
 
程序清单5-10 回复中断状态以避免屏蔽中断
 
 
public class TaskRunnable implements Runnable {
  BlockingQueue queue;
  .......
  public void run() {
    try{
      processTask(queue.take());
    }catch(Exception e) {
      Thread.currentThread().intterrupt(); //恢复被中断的状态
    }
  }
}

 
 
5.5 同步工具类
 
 
5.5.1闭锁
 
 
程序清单5-11 在计时测试中使用CountDownLatch来启动和停止线程
 
 
/**
 * 测试n个线程并发执行某个人物时需要的时间
 * latch    英[lætʃ] n.  门闩; 弹簧锁;
 */
public class TestHarness {
    
    //任务task就一份逻辑，用nThreads个线程并发执行
    public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);
        for (int i = 0; i < nThreads; i++) {
            Thread t = new Thread() {
                @Override
                public void run() {
                    try {
                        startGate.await(); //在每一个工作线程的开始处放一道栏杆，在主线程中控制开启
                        try {
                            task.run();
                        }finally {
                            endGate.countDown(); //每个线程运行完一个逻辑，关闭门数量就减一
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            t.start();
        }
        long start = System.nanoTime();
        startGate.countDown(); //启动门使得主线程同时释放所有工作线程
        endGate.await();    //结束门使主线程等待最后一个线程执行完成，而不是顺序地等待每个线程执行完成
        long end = System.nanoTime();
        return end - start;
    }
}


 
 
5.5.2FutureTask
 
 
程序清单5-2 使用FutureTask来提前加载稍后需要的数据
 
 
package com.multithread.unit05;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
//程序清单5-2  使用FutureTask来提前加载稍后需要的数据
public class Preloader {
    private final FutureTask future = new FutureTask<>(new Callable() {
        @Override
        public ProjectInfo call() throws Exception {
            return loadProjectInfo();
        }
    });
    ProjectInfo loadProjectInfo(){
        //TODO  从DB加载产品信息
        ProjectInfo info = new ProjectInfo("aaa");
        return info;
    }
    
    private final Thread thread = new Thread(future);
    
    //在构造函数和静态初始化方法中启动线程不是一种好方法，
    //因此提供start方法来启动线程
    public void start() {
        thread.start();
    }
    
    public ProjectInfo get() {
        try {
            return future.get();
        } catch (ExecutionException | InterruptedException e) {
            return null;
        }
    }
    
    public static void main(String[] args) {
        Preloader p = new Preloader();
        p.start();
        System.out.println(p.get());
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
class ProjectInfo{
    private String name;
}

 
 
5.5.3信号量Semaphore
 
 
程序清单5-14 使用信号量为容器设置边界
 
 
/**
 * 计数信号量（Counting Semaphore）用来控制同时访问某个特定资源的操作数量，
 * 或者同时执行某个指定操作的数量。计数信号量还可以实现某种资源池，或者对容器施加边界
 * 
 * Semaphore中管理着一组虚拟的许可（permit），许可的初始数量可通过构造函数来指定。
 * 在执行操作时可以首先获得许可（只要还有剩余的许可），并在使用以后释放许可。
 * 如果没有许可，那么acquire将阻塞直到有许可（或者直到被中断或操作超时）
 * release将返回一个许可给信号量
 */
public class BoundedHashSet {
    private final Set set;
    
    private final Semaphore sem;

    /**
     * 信号量的计数值会初始化为容器的最大值。
     */
    public BoundedHashSet(int bound) {
        this.set = Collections.synchronizedSet(new HashSet());
        this.sem = new Semaphore(bound);
    }
    /**
     * add操作向底层容器中添加一个元素之前，首先获取一个许可。
     * 如果add操作没有添加任何元素，那么会立刻释放许可。
     */
    public boolean add(T o) throws InterruptedException {
        sem.acquire();//获取（消费）一个许可
        boolean wasAdded = false;
        try {
            wasAdded = set.add(o);
            return wasAdded;
        } finally {
            if(!wasAdded)
                sem.release();//release()方法将返回一个许可给信号量
        }
        
    }
    /**
     * remove操作释放一个许可，使更多的元素能添加到容器中来。
     * 底层的Set实现并不知道关于边界的任何信息，这是由BoundedHashSet来处理的
     * @param o
     * @return
     */
    public boolean remove(Object o) {
        boolean wasRemoved = set.remove(o);
        if(wasRemoved)
            sem.release();//release()方法将返回一个许可给信号量
        return wasRemoved;
    }
}

 
 
程序清单5-15 通过CyclicBarrier协调细胞自动衍生系统中的计算(没看懂)
 
 
  /**
 * 通过栅栏来计算细胞的自动化模拟，在把模拟过程并行化时，
 * 为每一个元素分配一个独立的线程是不现实的，因为将产生过多线程，
 * 而在协调这些线程上导致的开销将降低计算性能。
 * 
 * 合理的做法：
 *  将问题分解成一定数量的子问题，为每个子问题分配一个线程来进行求解，之后再将所有的结果合并起来。
 * CellularAutomata将问题分解成N（CPU）个字问题。
 */
public class CellularAutomata {
    private final Board mainBoard;
    private final CyclicBarrier barrier;
    private final Worker[] workers;
    public CellularAutomata(Board board) {
        this.mainBoard = board;
        int count = Runtime.getRuntime().availableProcessors();
        
        this.barrier = new CyclicBarrier(count, new Runnable() {
            @Override
            public void run() {
                mainBoard.commitNewValues();
            }
        });
        this.workers = new Worker[count];
        for (int i = 0; i < count; i++) {
            workers[i] = new Worker(mainBoard.getSubBoard(count, i));
        }
    }
    
    //工人将细胞填满
    private class Worker implements Runnable{
        private final Board board;
        public Worker(Board board) {this.board = board;}

        @Override
        public void run() {
            while(!board.hasConverged())
                for (int x = 0; x < board.getMaxX(); x++)
                    for (int y = 0; y < board.getMaxY(); y++)
                        board.setNewValue(x, y, computeValue(x,y));
            
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                return;
            }
        }
        public int computeValue(int x, int y) {
            return x + y;
        }
        
        public void start() {
            for(int i = 0; i < workers.length; i++) 
                new Thread(workers[i]).start();
            mainBoard.waitForConvergence();
        }
        
    }
}

/**
 * 细胞类，方法内容都是瞎写的
 */
class Board{
    private int x,y,value;
    
    public void setNewValue(int x, int y,int value) {
        this.x = x;
        this.y = y;
        this.value = value;
    }
    
    //converge  英[kənˈvɜ:dʒ] 聚集
    public boolean hasConverged() {
        //TODO
        return true;
    }
    
    public int getMaxX() { return 100; }
    public int getMaxY() { return 100; }
    
    //计算新的值
    public void commitNewValues() {
        //TODO
    }
    
    //衍生子细胞
    public Board getSubBoard(int count, int i) {
        Board newBoard = new Board();
        newBoard.setNewValue(i, i, count);
        return newBoard;
    }
    
    public void waitForConvergence() {
        
    }
}

 
 
Exchanger
 
 
一个线程向缓冲区写数据，另一个线程从缓冲区读取数据，这些线程可以用Exchanger来汇合，并将满的缓冲区与空的缓冲区交换。当2个线程通过Exchanger交换对象时，这种交换就把2个对象安全地发布给另一方。
 
 
5.6 构建高效且可伸缩的结果缓存
 
 
程序清单5-16 使用HashMap和同步机制来初始化缓存，串行效率低
 
 
public interface Computable {
    V compute(A arg) throws InterruptedException;
}

public class ExpensiveFunction implements Computable {
    @Override
    public BigInteger compute(String arg) throws InterruptedException {
        return new BigInteger(arg);
    }   
}
//本Computable的compute中主要是缓存逻辑，嵌套了通过构造函数引用的外部计算逻辑，将缓存逻辑和业务计算逻辑分离
@ThreadSafe
public class Memoizer1 implements Computable {
    @GuardedBy("this")
    final Map cache = new HashMap<>();
    final Computable c;
    
    public Memoizerl(Computable c) { this.c = c; }

    @Override
    public synchronized V compute(A arg) throws InterruptedException {
        V result = cache.get(arg);
        if(result == null) {
            result = c.compute(arg);
            cache.put(arg, result);
        }
        return result;
    }
}

 
 
程序清单5-17 用ConcurrentHashMap替换HashMap(串行变并发)
 
 
/**
 * Memoizer2比Memoizer1有着更好的并发行为：多线程可以并发地使用它。
 * 但是作为缓存时仍然存在着一些不足——当2个线程同时调用compute时存在一个漏洞：
 * 可能会导致计算得到相同的值。在使用缓存的情况下，这只会带来低效，因为缓存的作用是避免相同的数据被计算多次。
 * 如果某个线程启动了一个开销很大的计算，而其他线程并不知道这个计算正在运行，那么很肯能会重复这个运算。
 */

//本Computable的compute中主要是缓存逻辑，嵌套了通过构造函数引用的外部计算逻辑，将缓存逻辑和业务计算逻辑分离
@ThreadSafe
class Memoizer2 implements Computable {
    @GuardedBy("this")
    final Map cache = new ConcurrentHashMap<>();
    final Computable c;
    
    public Memoizer2(Computable c) { this.c = c; }

    @Override
    public V compute(A arg) throws InterruptedException {
        V result = cache.get(arg);
        if(result == null) {
            result = c.compute(arg);
            cache.put(arg, result);
        }
        return result;
    }
}

 
 
程序清单5-18 基于Future的缓存封装器
 
 
/**
 * 将计算过程放到Map缓存中，而map又是并发集合，真正的并发并不是方法中的FutureTask（虽然其实现了Runable接口）
 * 而是外部的多线程并发调用Memoizer3的compute方法获取缓存的值，
 * 若是compute中曾计算过某key且已经结束了，则直接出结果，
 * 若是compute中曾计算过某key且还未结束，则阻塞等待先前的调用结束出结果，不再重复重头调用计算逻辑，
 * 若是compute中未曾计算过某key，则在未来过程中执行计算逻辑，并等待结果
 */
//本Computable的compute中主要是缓存逻辑，嵌套了通过构造函数引用的外部计算逻辑，将缓存逻辑和业务逻辑计算分离
class Memoizer3 implements Computable {
    @GuardedBy("this")
    final Map> cache = new ConcurrentHashMap<>();
    final Computable c;
    
    public Memoizer3(Computable c) { this.c = c; }
    
    @Override
    public V compute(A arg) throws InterruptedException {
        Future future = cache.get(arg);
        if(future == null) {
            Callable callable = new Callable() { //真正计算逻辑的调用
                @Override
                public V call() throws Exception {
                    return c.compute(arg);
                }
            };
            FutureTask futureTask = new FutureTask<>(callable); //将计算逻辑封装到Future过程中
            future = futureTask;
            cache.put(arg, futureTask); //将计算逻辑的过程放到缓存中（无论计算是否执行完成，key已经在缓存中占了）
            futureTask.run();//开启缓存的运算，这里将调用c.compute
        }
        
        V v = null;
        try {
            v = future.get();   //获取结果，若是Future过程已经计算完毕，直接出结果，还没计算完毕则阻塞等待
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return v;
    }
}

 
 
程序清单5-19 缓存的最终实现
 
 
class Memoizer4 implements Computable {
    @GuardedBy("this")
    final Map> cache = new ConcurrentHashMap<>();
    final Computable c;
    
    public Memoizer4(Computable c) { this.c = c; }
    
    @Override
    public V compute(A arg) throws InterruptedException {
        Future future = cache.get(arg);  //Future是接口，标准
        /*
         * if代码块仍然是非原子（nonatomic）的“先检查再执行”操作
         * 因此2个线程仍然可能同一时间内调用compute来计算相同的值，
         * 即二者都没有在缓存中找到期望的值，因此都开始计算
         * 改进见Memoizer4
         */
        if(future == null) { 
            Callable callable = new Callable() { //真正计算逻辑的调用
                @Override
                public V call() throws Exception {
                    return c.compute(arg);
                }
            };
            FutureTask futureTask = new FutureTask<>(callable); //将计算逻辑封装到Future过程中，FutureTask是实现类
            future = cache.putIfAbsent(arg, futureTask);    //将计算逻辑的过程放到缓存中（无论计算是否执行完成，key已经在缓存中占了）
            if(future == null)
                future = futureTask;
            futureTask.run();//开启缓存的运算，这里将调用c.compute
        }
        
        V v = null;
        try {
            v = future.get();   //获取结果，若是Future过程已经计算完毕，直接出结果，还没计算完毕则阻塞等待
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return v;
    }
}

 
 
 
  
当缓存的是Future而不是值时，Memoizer4未解决的问题：
 
 
 
 
     
  
  • 缓存污染：如果Future被取消或失败，应将Future从缓存中删除
    •  
  
  • 缓存逾期：可以通过使用FutureTask的子类解决。指定逾期时间
    •  
  
  • 缓存清理：移除旧的缓存结果，为新的计算结果腾空间或设值新值
    •  
 
 
 
 
 
程序清单5-20在因式分解Servlet中使用Memoizer4来缓存结果
 
 
/**
 * 分解因数缓存的终极实现，对比第一章实例
 *
 */
@ThreadSafe
class Factorizer implements Servlet {
    //1.自定义计算逻辑（因数分解）
    Computable c = new Computable() {
        @Override
        public BigInteger[] compute(BigInteger arg) throws InterruptedException {
            //因数分解，返回分解的因数数组 
            return factor(arg);
        }
    };
    
    //1.自定义计算逻辑（因数分解）
    Computable cache = new Memoizer4(c);

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        BigInteger i = extractFromReqest(req);
        BigInteger[] factors = factor(i);
        encodeIntoResponse(res,cache.compute(i));
    }
}

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(《JAVA并发编程实战》第五章 基础构建模块)

        

            

                
    
                    
  • 三菱PLC全套学习资料及应用手册
                        good2know

                        
    本文还有配套的精品资源，点击获取简介：三菱PLC作为工业自动化领域的核心设备，其系列产品的学习和应用需要全面深入的知识。本次资料包为学习者提供从基础到进阶的全方位学习资源，包括各种型号PLC的操作手册、编程指南、软件操作教程以及实际案例分析，旨在帮助用户系统掌握PLC的编程语言、指令系统及在各类工业应用中的实施。1.三菱PLC基础知识入门1.1PLC的基本概念可编程逻辑控制器（PLC）是工业自动化
    
                    
    • 
                    
  • （二）SAP Group Reporting (GR) 核心子模块功能及数据流向架构解析
                        

                        
    数据如何从子公司流转到合并报表的全过程，即数据采集→合并引擎→报表输出，特别是HANA内存计算如何优化传统ETL瓶颈。SAPGroupReporting(GR)核心模块功能及数据流向的架构解析，涵盖核心组件、数据处理流程和关键集成点，适用于S/4HANA1809+版本：一、核心功能模块概览模块功能关键事务码/FioriApp数据采集(DataCollection)整合子公司财务数据（SAP/非SA
    
                    
    • 
                    
  • 《极简思维》第三部分
                        小洋苏兮

                        
    整理你的人际关系如何改善人际关系？摘录：因为人际关系问题是人们生活中不快乐的主要原因。感想：感觉这个说的挺对，之前我总是埋头学习，不管舍友不管自己的合作伙伴的一些事情，但实际上，这学期关注了之后好多了摘录：“亲密关系与社交会让你健康而快乐。这是基础。太过于关注成就或不太关心人际关系的人都不怎么快乐。基本上来说，人类就是建立在人脉关系上的。”感想：但是如果有时想的太多就不太好，要以一个开放的心态跟别
    
                    
    • 
                    
  • 英伟达靠什么支撑起了4万亿？AI泡沫还能撑多久？
                        

                        
    英伟达市值突破4万亿美元，既是AI算力需求爆发的直接体现，也暗含市场对未来的狂热预期。其支撑逻辑与潜在风险并存，而AI泡沫的可持续性则取决于技术、商业与地缘政治的复杂博弈。⚙️一、英伟达4万亿市值的核心支撑因素技术垄断与生态壁垒硬件优势：英伟达GPU在AI训练市场占有率超87%，H100芯片的FP16算力达1979TFLOPS，领先竞品3-5倍。CUDA生态：400万开发者构建的软件护城河，成为A
    
                    
    • 
                    
  • Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
                        倾听铃的声
后端springjavamvc开发语言分布式
                        
    前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
    
                    
    • 
                    
  • JVM 内存模型深度解析：原子性、可见性与有序性的实现
                        练习时长两年半的程序员小胡
JVM深度剖析：从面试考点到生产实践jvmjava内存模型
                        
    在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
    
                    
    • 
                    
  • Flowable 高级扩展：自定义元素与性能优化实战
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
                        
    在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
    
                    
    • 
                    
  • 互信息：理论框架、跨学科应用与前沿进展
                        大千AI助手
人工智能Python#OTHER人工智能深度学习算法互信息香农通信随机变量
                        
    1.起源与核心定义互信息（MutualInformation,MI）由克劳德·香农（ClaudeShannon）在1948年开创性论文《AMathematicalTheoryofCommunication》中首次提出，该论文奠定了现代信息论的基础。互信息用于量化两个随机变量之间的统计依赖关系，定义为：若已知一个随机变量的取值，能为另一个随机变量提供的信息量。数学上，对于离散随机变量XXX和YYY，
    
                    
    • 
                    
  • 企业级区块链平台Hyperchain核心原理剖析
                        boyedu
区块链区块链企业级区块链平台Hyperchain
                        
    Hyperchain作为国产自主可控的企业级联盟区块链平台，其核心原理围绕高性能共识、隐私保护、智能合约引擎及可扩展架构展开，通过多模块协同实现企业级区块链网络的高效部署与安全运行。以下从核心架构、关键技术、性能优化、安全机制、应用场景五个维度展开剖析：一、核心架构：分层解耦与模块化设计Hyperchain采用分层架构，将区块链功能解耦为独立模块，支持灵活组合与扩展：P2P网络层由验证节点（VP）
    
                    
    • 
                    
  • 车载刷写架构 --- 刷写思考扩展
                        汽车电子实验室
电子电器架构——刷写方案架构开发语言关于网关转发性能引起的思考汽车中央控制单元HPC软件架构车载诊断进阶篇
                        
    我是穿拖鞋的汉子，魔都中坚持长期主义的汽车电子工程师。老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师：做到欲望极简，了解自己的真实欲望，不受外在潮流的影响，不盲从，不跟风。把自己的精力全部用在自己。一是去掉多余，凡事找规律，基础是诚信；二是系统思考、大胆设计、小心求证；三是“一张纸制度”，也就是无论多么复杂的工作内容，要在一张纸上描述清楚；四是要坚决反对虎头蛇尾，反对繁文缛节，反对老
    
                    
    • 
                    
  • 在线人数统计业务设计（场景八股文）
                        

                        
    业务问题在当经的网站中，在线人数的实时统计已经是一个必不可少的模块了，并且该统计功能最好能够按不同的时间间隔做的统计，现在需要你设计一个在线人数统计的模块，你应该怎么进行设计的呢？背景一个网校下会有多个学员。目前平台大概有十个，平台对应的网校大概五十几个，平均一个网校会有5w个用户，预计总人数为200w，最该学员的在线人数在10w左右。设计思路最开始的时候，想到的就是使用mysql直接实现，但是明
    
                    
    • 
                    
  • 【ARM】FPU,VFP,ASE,NEON,SVE...是什么意思？
                        亿道电子Emdoor
ARMarm开发ARM
                        
    1、文档目标对执行浮点和SIMD操作的逻辑的各种名称的缩写词进行简要解释。2、问题场景Arm处理器内核中有用于执行浮点和SIMD操作的逻辑，有各种名称。它们通常是一系列的缩写形式，因此本文旨在对每一个缩写词进行简要解释。3、软硬件环境1、软件版本：不涉及2、电脑环境：不涉及4、相关缩写FPU(Floating-PointUnit)浮点单元浮点单元是处理器核心中的一个模块，用于使用浮点数执行算术运算
    
                    
    • 
                    
  • 基于redis的Zset实现作者的轻量级排名
                        周童學
Javaredis数据库缓存
                        
    基于redis的Zset实现轻量级作者排名系统在今天的技术架构中，Redis是一种广泛使用的内存数据存储系统，尤其在需要高效检索和排序的场景中表现优异。在本篇博客中，我们将深入探讨如何使用Redis的有序集合（ZSet）构建一个高效的笔记排行榜系统，并提供相关代码示例和详细的解析。1.功能背景与需求假设我们有一个笔记分享平台，用户可以发布各种笔记，系统需要根据用户发布的笔记数量来生成一个实时更新的
    
                    
    • 
                    
  • 北斗短报文兜底、5G-A增强：AORO P1100三防平板构建应急通信网络
                        

                        
    公网中断的灾区现场，泥石流阻断了最后一条光缆。一支救援队却在废墟间有序穿行，队长手中的三防平板正闪烁着北斗卫星信号，定位坐标与伤亡信息化作一行行短报文，穿透通信孤岛直达指挥中心。这是AOROP1100三防平板搭载的北斗短报文功能在应急救援中的真实场景，更代表了工业移动终端在极端环境下的能力跃迁。AOROP1100三防平板作为遨游通讯2025年推出的旗舰三防设备，AOROP1100三防平板的技术基底
    
                    
    • 
                    
  • 猎板 PCB 控深槽工艺：5G 基站散热模块的关键支撑
                        猎板PCB黄浩
5G运维数据库
                        
    PCB控深槽工艺在5G基站散热模块中的关键作用：猎板PCB的技术突破在5G基站的密集高频信号与高功率运行环境下，散热性能直接决定了设备的稳定性和寿命。猎板PCB通过创新性的控深槽工艺（控深锣/控深铣），结合材料科学与结构优化，为5G基站散热模块提供了高精度、高可靠性的解决方案，有效攻克了高热负荷下的技术瓶颈。一、5G基站散热的核心挑战热负荷激增：5G基站的射频功放（PA）、电源管理模块等器件功耗显
    
                    
    • 
                    
  • Redis + Caffeine 实现高效的两级缓存架构
                        周童學
Java缓存redis架构
                        
    Redis+Caffeine实现高效的两级缓存架构引言在现代高并发系统中，缓存是提升系统性能的关键组件之一。传统的单一缓存方案往往难以同时满足高性能和高可用性的需求。本文将介绍如何结合Redis和Caffeine构建一个高效的两级缓存系统，并通过三个版本的演进展示如何逐步优化代码结构。项目源代码：github地址、gitee地址两级缓存架构概述两级缓存通常由本地缓存（如Caffeine）和分布式缓
    
                    
    • 
                    
  • 元宇宙中的视觉技术：虚拟化身与场景生成
                        xcLeigh
计算机视觉CV元宇宙虚拟化身场景生成AIGC数字孪生
                        
    元宇宙中的视觉技术：虚拟化身与场景生成前言一、元宇宙与视觉技术的深度关联1.1元宇宙概念深度剖析1.2视觉技术：元宇宙的“灵魂之窗”二、虚拟化身：数字世界的“第二自我”2.1虚拟化身技术的深度解析2.1.1核心技术构成2.1.2技术实现原理与流程2.2虚拟化身的应用领域及案例展示2.2.1游戏娱乐领域2.2.2教育培训领域三、场景生成：构建元宇宙的虚拟天地3.1场景生成技术全景透视3.1.1关键技
    
                    
    • 
                    
  • C++编程基础与面向对象概念解析
                        侯昂
面向对象编程C++语法函数类与对象继承与多态性
                        
    C++编程基础与面向对象概念解析背景简介C++是一种广泛使用的面向对象编程语言，它允许开发者创建高效、灵活且功能强大的程序。本文基于《C++Primer》一书的章节内容，深入解析C++的核心概念和面向对象编程原则，旨在帮助读者构建扎实的C++编程基础。面向对象编程的原则软件危机与进化介绍了软件危机的产生和软件进化的必要性，强调了面向对象编程（OOP）在应对这些问题中的优势。面向对象编程范式讨论了面
    
                    
    • 
                    
  • K8s常用的命令
                        尚未来-
运维k8s
                        
    一、基础命令查看集群信息bashkubectlcluster-info#显示集群端点和服务信息查看节点bashkubectlgetnodes#列出所有节点kubectldescribenode#查看节点详细信息查看命名空间bashkubectlgetnamespaces#列出所有命名空间切换命名空间bashkubectlconfigset-context--current--namespace=二
    
                    
    • 
                    
  • Anaconda 和 Miniconda：功能详解与选择建议
                        古月฿
python入门pythonconda
                        
    Anaconda和Miniconda详细介绍一、Anaconda的详细介绍1.什么是Anaconda？Anaconda是一个开源的包管理和环境管理工具，在数据科学、机器学习以及科学计算领域发挥着关键作用。它以Python和R语言为基础，为用户精心准备了大量预装库和工具，极大地缩短了搭建数据科学环境的时间。对于那些想要快速开展数据分析、模型训练等工作的人员来说，Anaconda就像是一个一站式的“数
    
                    
    • 
                    
  • 听覃杰007写作精进课第五天分享心得
                        曹端春

                        
    早上听覃老大直播007写作精进课程第五天，获益良多。关于写作的黄金三法：多读，多写，多动，确实说到了写作的真谛。一，多读，扩大阅读面，精读相关经典作家的经典作品，逐步构建自己的知识体系；阅读方面推荐指读法，这是聪明人用的笨办法，读本离眼睛远些，可让视野更开阔些，能提高30％的速度；二，多写，象高手一样靠汗水写作，写不出来硬写，找准自己的定位，在一个行业内了解100个关键词，输出糸列文章，并且多分享
    
                    
    • 
                    
  • Qwen3 大模型实战：使用 vLLM 部署与函数调用（Function Call）全攻略
                        曦紫沐
大模型大模型部署Qwen3vLLM函数调用
                        
    文章摘要本文将带你从零开始，深入掌握如何使用Qwen3-8B大语言模型，结合vLLM进行高性能部署，并通过函数调用（FunctionCall）实现模型与外部工具的智能联动。我们将详细讲解部署命令、调用方式、代码示例及实际应用场景，帮助你快速构建基于Qwen3的智能应用。一、Qwen3简介与部署环境准备Qwen3是通义千问系列的最新一代大语言模型，具备强大的自然语言理解和生成能力，尤其在函数调用、工
    
                    
    • 
                    
  • 链商拉不到人能赚钱么，谈谈我的看法
                        糖葫芦不甜

                        
    链商作为一种新兴的商业形态，往往依赖于用户网络的扩展和交易量的增加来实现价值增长，但这并不意味着没有直接拉新就无法盈利。以下是我对这一问题的几点看法：招合作伙伴↓微信在文章底部。首先，链商能否赚钱，关键在于其是否能提供独特且有价值的产品或服务。如果链商平台能够构建出高效、透明、安全的价值交换体系，解决行业痛点，提升用户体验，那么即使没有大规模的拉新活动，也能通过现有用户的口碑传播和持续使用来产生稳
    
                    
    • 
                    
  • Pandas：数据科学的超级瑞士军刀
                        科技林总
DeepSeek学AI人工智能
                        
    **——从零基础到高效分析的进化指南**###**一、Pandas诞生：数据革命的救世主****2010年前的数据分析噩梦**：```python#传统Python处理表格数据data=[]forrowincsv_file:ifrow[3]>100androw[2]=="China":data.append(float(row[5])#代码冗长易错！```**核心痛点**：-Excel处理百万行崩
    
                    
    • 
                    
  • 大数据之路：阿里巴巴大数据实践——大数据领域建模综述
                        

                        
    为什么需要数据建模核心痛点数据冗余：不同业务重复存储相同数据（如用户基础信息），导致存储成本激增。计算资源浪费：未经聚合的明细数据直接参与计算（如全表扫描），消耗大量CPU/内存资源。数据一致性缺失：同一指标在不同业务线的口径差异（如“活跃用户”定义不同），引发决策冲突。开发效率低下：每次分析需重新编写复杂逻辑，无法复用已有模型。数据建模核心价值性能提升：分层设计（ODS→DWD→DWS→ADS）
    
                    
    • 
                    
  • 学C++的五大惊人好处
                        

                        
    为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
    
                    
    • 
                    
  • Android 基础知识：Android 应用权限详解
                        流水mpc
android
                        
    这篇文章为大家系统的梳理一下Android权限相关的知识，在日常开发中，我们都用过权限，但是对于权限的一些细节我们可能掌握的还不够全面，这篇文章会全面的为大家介绍权限相关的知识。当然，本篇文章依然是参考了Google的官方文档：应用权限。本文目录一、认识Android权限（一）Android系统为什么需要权限？Android系统设置权限的目的是保护Android用户的隐私。对于用户的敏感数据And
    
                    
    • 
                    
  • Selenium基础教程
                        lemontree1945
seleniumpython测试工具
                        
    1.Selenium环境安装1.1浏览器安装Chrome和ChromeDriver下载地址:https://googlechromelabs.github.io/chrome-for-testing/注意：驱动版本号要和浏览器版本号一致；安装后关闭浏览器自动更新:services.msc:打开系统服务找到和google相关的服务，全部修改为禁用1.2安装第三方库seleniumpipinstall
    
                    
    • 
                    
  • 机器学习必备数学与编程指南：从入门到精通
                        a小胡哦
机器学习基础机器学习人工智能
                        
    一、机器学习核心数学基础1.线性代数（神经网络的基础）必须掌握：矩阵运算（乘法、转置、逆）向量空间与线性变换特征值分解与奇异值分解(SVD)为什么重要：神经网络本质就是矩阵运算学习技巧：用NumPy实际操作矩阵运算2.概率与统计（模型评估的关键）核心概念：条件概率与贝叶斯定理概率分布（正态、泊松、伯努利）假设检验与p值应用场景：朴素贝叶斯、A/B测试3.微积分（优化算法的基础）重点掌握：导数与偏导
    
                    
    • 
                    
  • Android 媒体播放开发完全指南
                        安卓开发者
AndroidJetpackandroid媒体python
                        
    引言在当今移动应用生态中，媒体播放功能已成为许多应用的核心组成部分。无论是音乐流媒体应用、视频平台、播客客户端还是游戏应用，都需要强大的媒体播放能力。Android平台提供了丰富的API来支持各种媒体播放场景。本文将全面介绍Android媒体播放的开发技术，从基础到高级功能实现。一、Android媒体播放基础1.1支持的媒体格式Android原生支持多种媒体格式：音频：MP3、AAC、FLAC、W
    
                    
    • 
                                
  • sql统计相同项个数并按名次显示
                                    朱辉辉33
javaoracle
                                    
    现在有如下这样一个表： 
A表 
ID Name time 
------------------------------ 
0001 aaa 2006-11-18 
0002 ccc 2006-11-18 
0003 eee 2006-11-18 
0004 aaa 2006-11-18 
0005 eee 2006-11-18 
0004 aaa 2006-11-18 
0002 ccc 20
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列-目录
                                    白糖_
JQuery Mobile
                                    
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。 
  
从现在起，往后一段时间，我打算
    
                                
    • 
                                
  • 如何给线程池命名
                                    daysinsun
线程池
                                    
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下： 
    
public class Named
    
                                
    • 
                                
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
                                    周凡杨
html解析errorreadyState
                                    
      
错误：  IE   中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"      
  
  
现象：  同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    
                                
    • 
                                
  • java上传
                                    g21121
java
                                    
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 
下面是servlet的代码： 
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    
                                
    • 
                                
  • SpringMVC配置学习
                                    510888780
springmvc
                                    
    spring MVC配置详解 
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 
 
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    
                                
    • 
                                
  • spring mvc-jfreeChart 柱图(1)
                                    布衣凌宇
jfreechart
                                    
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 
第二步：配置web.xml; 
web.xml代码如下 
<servlet> 
    <servlet-name>jfreechart</servlet-nam
    
                                
    • 
                                
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
                                    aijuans
Spring3
                                    
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    
                                
    • 
                                
  • java 线程池使用 Runnable&Callable&Future
                                    antlove
javathreadRunnablecallablefuture
                                    
    1. 创建线程池 
ExecutorService executorService = Executors.newCachedThreadPool(); 
  
2. 执行一次线程，调用Runnable接口实现 
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    
                                
    • 
                                
  • XML语法元素结构的总结
                                    百合不是茶
xml树结构
                                    
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    
                                
    • 
                                
  • 改变eclipse编码格式
                                    bijian1013
eclipse编码格式
                                    
    1.改变整个工作空间的编码格式 
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。 
        Eclipse->window->preferences->General->workspace-
    
                                
    • 
                                
  • javascript中return的设计缺陷
                                    bijian1013
JavaScriptAngularJS
                                    
    代码1： 
<script>
var gisService = (function(window) 
{ 

    return
    {
        name:function ()
        {
            alert(1);
        }
    };

})(this);

gisService.name();
&l
    
                                
    • 
                                
  • 【持久化框架MyBatis3八】Spring集成MyBatis3
                                    bit1129
Mybatis3
                                    
    pom.xml配置 
Maven的pom中主要包括： 
 
 MyBatis 
 MyBatis-Spring 
 Spring 
 MySQL-Connector-Java 
 Druid 
 applicationContext.xml配置     
<?xml version="1.0" encoding="UTF-8"?>
&
    
                                
    • 
                                
  • java web项目启动时自动加载自定义properties文件
                                    bitray
javaWeb监听器相对路径
                                    
    创建一个类 
public class ContextInitListener implements ServletContextListener 
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 
 
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 
 

    <listener>
        <des
    
                                
    • 
                                
  • 用nginx区分文件大小做出不同响应
                                    ronin47

                                    
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    
                                
    • 
                                
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Random;

public class ContinuousPoker {

    /**
     * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
     * 2-10为数字本身，A为1，J为1
    
                                
    • 
                                
  • 翟鸿燊老师语录
                                    ccii
翟鸿燊
                                    
    一、国学应用智慧TAT之亮剑精神A 
1. 角色就是人格 
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。 
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    
                                
    • 
                                
  • [光速与宇宙]进行光速飞行的一些问题
                                    comsci
问题
                                    
     
 
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家 
    仅仅是猜想。。。未经官方证实 
 
 
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    
                                
    • 
                                
  • oracle undo解析
                                    cwqcwqmax9
oracle
                                    
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 
 
Undo是干嘛用的？         &nb
    
                                
    • 
                                
  • java中各种集合的详细介绍
                                    dashuaifu
java集合
                                    
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    
                                
    • 
                                
  • 卸载windows服务的方法
                                    dcj3sjt126com
windowsservice
                                    
    卸载Windows服务的方法 
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    
                                
    • 
                                
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
                                    dcj3sjt126com
iosxcode
                                    
           
      
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html 
Excerpt: 
 
 You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    
                                
    • 
                                
  • 2014之C++学习笔记（一）
                                    Etwo
C++EtwoEtwoiterator迭代器
                                    
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    
                                
    • 
                                
  • js跨越获取数据问题记录
                                    haifengwuch
jsonpjsonAjax
                                    
    js的跨越问题，普通的ajax无法获取服务器返回的值。 
 
  第一种解决方案，通过getson，后台配合方式，实现。 
Java后台代码： 
protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException { 
String ca
    
                                
    • 
                                
  • 蓝色jQuery导航条
                                    ini
JavaScripthtmljqueryWebhtml5
                                    
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    
                                
    • 
                                
  • linux部署jdk,tomcat,mysql
                                    kerryg
jdktomcatlinuxmysql
                                    
    1、安装java环境jdk: 
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。 
   1.1）、卸载： 
     （rpm -qa :查询已经安装哪些软件包； 
       rmp -q 软件包：查询指定包是否已
    
                                
    • 
                                
  • DOMContentLoaded VS onload VS onreadystatechange
                                    mutongwu
jqueryjs
                                    
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 
 
2. onload是最早支持的事件，要求所有资源加载完毕触发。 
 
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    
                                
    • 
                                
  • sql批量插入数据
                                    qifeifei
批量插入
                                    
    hi， 
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。 
   
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    
                                
    • 
                                
  • log4j打印日志文件 如何实现相对路径到 项目工程下
                                    thinkfreer
Weblog4j应用服务器日志
                                    
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 
 
 
需求： 
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    
                                
    • 
                                
  • linux下mysql-5.6.23.tar.gz安装与配置
                                    笑我痴狂
mysqllinuxunix
                                    
    1.卸载系统默认的mysql 
 
[root@localhost ~]# rpm -qa | grep mysql 
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    
                                
    •