健小周
健小周

JUC并发编程

java并发编程

我们在用java并发编程时会用到java.util.concurrent（简称JUC）包，该包下包含了并发编程的类。

什么是线程

线程（thread）是操作系统能够进行运算调度的最小单位。
并发编程顾名思义就是让多个线程并行执行（多核CPU下），提高系统的并发能力。

线程状态

==NEW== 初始状态
==RUNNABLE== 运行状态
==BLOCKED== 阻塞状态
==WAITING== 等待状态
==TIME_WAITING== 超时等待状态
==TERMINATED== 终止状态

lock和synchronized 的区别

1、synchronized 是java关键字，Lock是juc下的api
2、synchronized 为非公平锁，lock可以是公平锁、非公平锁
3、synchronized 会自动释放锁，无需我们在程序中手动释放；lock必须调用unlock进行释放。
4、使用synchronized 时，如果线程阻塞，另外一个线程会一直等待；但是lock可以使用trylock尝试获取，超过一定时间获取不到便放弃。
5、synchronized 可用于方法、代码块等适合代码量较小的场景，lock可以精确锁定，具体到某行代码。

线程的精确通知

线程直接通知的三大步骤：
==条件判断==
==执行动作==
==通知线程==
Object类有wait和notify/notifyAll通知，但是不能做到精确的通知。那么在juc下有没有可以精确通知的实现方式呢？答案：==有==
先看api中的Condition接口


在这里插入图片描述

来段示例，让三个线程交替执行创建、获取、提交的动作

package com.example.springboot.test.juc.notice;

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

/**
 * condition实现精准通知
 * 通知三部曲：
 * 1、条件判断
 * 2、逻辑执行
 * 3、通知
 */
public class Notice {
    public static void main(String[] args) {
        Flow flow = new Flow();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                flow.create();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                flow.get();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                flow.submit();
            }
        },"C").start();

    }


}

class Flow{
    String flag = "A";
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    public void create(){
        lock.lock();
        try {
            while (!"A".equals(flag)) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "创建");
            flag = "B";
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void get(){
        lock.lock();
        try {
            while(!"B".equals(flag)){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "获取");
            flag = "C";
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void submit(){
        lock.lock();
        try {
            while (!"C".equals(flag)) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "提交");
            flag = "A";
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

8锁问题知识点

1、被 synchronized 修饰的方式，锁的对象是方法的调用者。
2、被 static 修饰，锁的对象就是 Class模板对象,这个则全局唯一！

//锁的是唯一的class模板
synchronized(Hello.class){
}
//锁的是new出来的当前示例对象
synchronized(this){
}

不安全的集合类

list

我们经常用到的ArrayList非线程安全的，在并发场景下进行add操作会出现并发修改异常（ConcurrentModificationException），怎么避免异常？
1、使用安全集合vector

List list = new Vector<>();

2、使用工具类中的转线程安全的方法

List list = Collections.synchronizedList(new ArrayList<>())

3、使用juc下的copyonwrite

List list = new CopyOnWriteArrayList<>()

这里的copyonwrite是一种思想，写数据的时候利用拷贝的副本来执行，然后移动指针指向新的数据

set

同样的经常使用到的HashSet也是非线程安全的，HashSet本质是HashMap，存放的为HashMap中的key，所以是不重复的。
那么怎么实现线程安全呢？
1、使用工具类的转线程安全的方法

Set set = Collections.synchronizedSet(new HashSet<>())

2、copyonwrite思想

Set set = new CopyOnWriteArraySet()

map

HashMap也是非线程安全的，如果使用线程安全的map可以使用concurrentHashMap，如下：

Map map = new ConcurrentHashMap<>();

探索HashMap

HashMap本质是数组 + 链表、红黑树的数据结构
初始化容量为2的4次方，即16，加载因子为0.75f。
put数据时，先根据key的hash值判断数据存放哪个数组，如果数组中有值，则插入数组的链表中，当链表长度大于等于8时，转化为红黑树。

读写锁

并发包下的读写锁ReadWriteLock，有两个方法readLock()和writeLock()，返回类型为Lock，实现类有ReentrantReadWriteLock。
使用方法如下，lock和unlock同样需要成对出现，防止死锁。

ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
//do something
lock.readLock().unlock();
lock.writeLock().lock();
//do something
lock.writeLock().unlock();

阻塞队列

阻塞队列顾名思义，使用时会阻塞，典型的应用为生产者消费者模式，juc下接口类为BlockingQueue，一下为实现类


在这里插入图片描述

其中有一个特殊的队列SynchronousQueue，此队列只存一个元素，现存现取。

阻塞队列在什么情况下会阻塞呢？

1、当队列满了，继续往队列中添加时。
2、当队列为空时，要从队列取值时。

使用方法

方法 第一组会抛出异常 返回一个布尔值，不会抛出异常 延时等待 一直等待
插入 add() offer（e） offer（e，time） put（）
取出 remove() poll（） poll（time） take（）
检查 element（） peek（） - -

函数式接口

juc下定义了四个函数式接口，分别为：
==Function== ： 有一个输入参数有一个输出参数
==Consumer==：有一个输入参数，没有输出参数
==Supplier==：没有输入参数，只有输出参数
==Predicate==：有一个输入参数，判断是否正确！

异步回退

CompletableFuture类可以实现异步回退的功能，该类实现了Future接口。
实现方式如下：

package com.example.springboot.test.juc.async;

import java.util.concurrent.CompletableFuture;

public class ComplateFutureTest {
    public static void main(String[] args) throws Exception {
        CompletableFuture completableFuture1 = CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread().getName() + "异步执行完成");
        });
        System.out.println("无返回值的" + completableFuture1.get());
        CompletableFuture completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName() + "异步执行返回结果");
//            int i = 5/0;
            return 1024;
        });
        System.out.println(completableFuture.whenComplete((t, r) -> {
            System.out.println("t--->" + t + "\r\n" + "r--->" + r);
        }).exceptionally((s) -> {
            return 404;
        }).get());
    }
}

线程池

线程池的默认创建方式不支持使用，看代码可以发现他们最终都使用了ThreadPoolExecutor自定义创建

package com.example.springboot.test.juc;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,//常驻核心线程数
                6,//线程池能够容纳的同时执行的最大线程数
                3L,//线程空闲时间，达到指定值时会销毁线程，直到剩下core个
                TimeUnit.SECONDS,//时间单位，配合keepAliveTime使用
                new LinkedBlockingQueue(3),//缓存队列，当线程大于max时会进入阻塞队列
                Executors.defaultThreadFactory(),//线程工厂，用于生产一组相同任务的线程
                new ThreadPoolExecutor.CallerRunsPolicy());//拒绝策略，当线程超过core+max+queue数量时会用到
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.execute(()->{
                System.out.println(Thread.currentThread().getName() + "正在执行任务");
            });
        }

        threadPoolExecutor.shutdown();
    }
}

其中拒绝策略有四种，分别为：
•==AbortPolicy（默认）==：丢弃任务并抛出RejectedExecutionException异常。
• ==DiscardPolicy== ：丢弃任务，但是不抛出异常，这是不推荐的做法。
• ==DiscardOldestPolicy== ：抛弃队列中等待最久的任务，然后把当前任务加入队列中。
• ==CallerRunsPolicy== ：调用任务的run()方法绕过线程池直接执行，谁调用的谁来处理。

juc的辅助类

juc下有三个辅助类，分别是CountDownLatch、CyclicBarrier、Semaphore。
下面分别介绍三个辅助类的作用。

CountDownLatch

CountDownLatch是一个减法计数器，有两个常用方法countDown()和await()。countDown()每调用一次计数器会减一，await方法会阻塞等待所有的线程执行完成，它不要求调用countDown线程等待计数到达零之前继续，它只是阻止任何线程通过await ，直到所有线程可以通过。

package com.example.springboot.test.juc.assist;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "执行完成");
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await(5, TimeUnit.SECONDS);
        System.out.println("全部执行完成");
    }
}

CyclicBarrier

CyclicBarrier译为篱栅，围栏。它允许一组线程全部等待彼此达到共同屏障点的同步辅助。 循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。有两个await()方法，如果当前线程不是最后一个线程，那么它被禁用以进行线程调度，并且处于休眠状态，直到所有的线程都调用或者调用reset()方法，用法如下：

package com.example.springboot.test.juc.assist;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

public class CyclicBarrierTest {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, ()->{
            System.out.println("队伍集合成功");
        });

        for (int i = 0; i < 5; i++) {
            final int num = i;
            new Thread(()->{
                System.out.println(num + "对集合完毕");
                try {
                    cyclicBarrier.await(2, TimeUnit.SECONDS);
                } catch (Exception e){

                }
            }).start();
        }
    }
}

Semaphore

Semaphore译为信号量，信号量维护一组许可证，调用acquire()会阻塞，直到许可证可用，然后才能使用它。 每个release()添加许可证，潜在地释放阻塞获取方。用法如下：

package com.example.springboot.test.juc.assist;

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "来了");
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(Thread.currentThread().getName() + "走了");
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

JMM

JMM意思是Java memory model，Java内存模型，它是一种理论，和线程安全相关。
所有的线程是如何工作的：

八大操作：

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

  • lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态

  • unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

  • read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用

  • load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中

  • use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令

  • assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中

  • store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用

  • write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

    在这里插入图片描述

    JMM对这八种指令的使用，制定了如下规则：

  • 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write

  • 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存 （可见）

  • 不允许一个线程将没有assign的数据从工作内存同步回主内存

  • 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作

  • 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁

  • 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值

  • 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量

  • 对一个变量进行unlock操作之前，必须把此变量同步回主内存

volatile

volatile的特性：

  • 保证可见性，即不同线程对这个变量进行操作时的可见性，一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
  • 禁止进行指令重排序。
  • volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。
    可见性验证： 
package com.example.springboot.test.juc.jmm;

import java.util.concurrent.TimeUnit;

public class VolateTest {
    volatile static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println("让线程开始运行");
            while (flag){

            }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        flag = false;
        System.out.println("此时flag为：" + flag);
    }
}

以上代码在flag不加volatile时，程序会一直在while中循环，因为主线程修改了flag的值，对于线程A是不可见的，所以线程A会一直循环，加上volatile之后，主线程对flag变量的操作对于线程A就可见了，会停止循环。
不保证原子性验证：

package com.example.springboot.test.juc.jmm;

import java.util.concurrent.CountDownLatch;

public class VolatileTest2 {
    volatile static int num = 0;
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int m = 0; m < 5; m++) {
            new Thread(()->{
                for (int i = 0; i < 20; i++) {
                    add();
                }
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await();
        System.out.println("当前num的值为:" + num);
    }

    private /**synchronized*/ static void add(){
        num++;
    }
}

num加与不加volatile，最终num的值都不是期望的100，如果在add方法上
加上synchronized修饰，则一定是100。
那么有没有办法在不使用synchronized时也能保证其正确性？
juc提供了一系列原子类，比较常用的有AtomicInteger。
如下：

package com.example.springboot.test.juc.jmm;

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

public class VolatileTest2 {
//    volatile static int num = 0;
    static AtomicInteger num = new AtomicInteger();
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int m = 0; m < 5; m++) {
            new Thread(()->{
                for (int i = 0; i < 20; i++) {
                    add();
                }
                countDownLatch.countDown();
            }).start();
        }
        countDownLatch.await();
        System.out.println("当前num的值为:" + num);
    }

    private static void add(){
        num.getAndIncrement();
    }
}

此时add方法不使用synchronized修饰也能得到期望的100值。
禁止指令重排
这个无法用代码验证，属于理论知识。
指令重排是指代码在实际运行时不一定是按照你写的顺序执行的。
源代码->编译器（优化重排）->指令并行重排-> 内存系统的重排-> 最终执行的！
代码经过编译器，再经过重排，最后是最终的执行结果。单线程也不能避免指令重排。
如程序：

int a = 0;//第一步
int b = 1;//第二步
a = a + 1;//第三步
int c = a + b;//第四步

经过重排后，程序不一定按照1234步执行，可能是1234、1324、2134、2314、3124、3214。
volatile使用内存屏障（Memory Barrier）来禁止指令重排，内存屏障有两个作用：

  • 保证特定的执行顺序！
  • 保证某些变量的内存可见性 （votatile就是用它这个特性来实现的）

单例模式

饿汉式模式

package com.example.springboot.test.juc.single;

/**
 * 饿汉式模式
 */
public class HungryMan {
    //构造器私有
    private HungryMan(){

    }
    private static final HungryMan hungryMan = new HungryMan();

    public static HungryMan getSingleInstance(){
        return hungryMan;
    }
}
class HungryTest{
    public static void main(String[] args) {
        HungryMan hungryMan = HungryMan.getSingleInstance();
        HungryMan hungryMan2 = HungryMan.getSingleInstance();
        System.out.println(hungryMan.hashCode());
        System.out.println(hungryMan2.hashCode());
    }
}

懒汉式

package com.example.springboot.test.juc.single;

/**
 * 懒汉式模式
 */
public class LazyMan {
    private LazyMan(){}
    private volatile static LazyMan lazyMan = null;
    public static LazyMan getSingleInstance(){
        if(lazyMan == null){
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }

        return lazyMan;
    }
}
class LazyTest{
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(LazyMan.getSingleInstance().hashCode());
            }).start();
        }
    }
}

这种懒汉式会被反射式破坏，不安全

package com.example.springboot.test.juc.single;

import java.lang.reflect.Constructor;

/**
 * 懒汉式模式
 */
public class LazyMan {
    private LazyMan(){
        System.out.println("构造器");
    }
    private volatile static LazyMan lazyMan = null;
    public static LazyMan getSingleInstance(){
        if(lazyMan == null){
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }

        return lazyMan;
    }
}
class LazyTest{
    public static void main(String[] args) throws Exception {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//                System.out.println(LazyMan.getSingleInstance().hashCode());
//            }).start();
//        }
        Constructor constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan lazyMan = (LazyMan) constructor.newInstance();
        LazyMan lazyMan2 = (LazyMan) constructor.newInstance();
        LazyMan lazyMan1 = LazyMan.getSingleInstance();
        System.out.println(lazyMan.hashCode());
        System.out.println(lazyMan1.hashCode());
        System.out.println(lazyMan2.hashCode());
    }
}

使用枚举类：

package com.example.springboot.test.juc.single;

import java.lang.reflect.Constructor;

public enum  EnumSingle {
    SINGLEINSTANCE;
    public EnumSingle getSingleInstance(){
        return SINGLEINSTANCE;
    }
}

class EnumTest {
    public static void main(String[] args) throws Exception {
        Constructor constructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        EnumSingle enumSingle = constructor.newInstance();
        System.out.println(enumSingle.hashCode());
    }
}

在jdk没被修改的情况下，枚举类是安全的单例模式。

CAS

package com.zeroun.test.cas;

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

public class CasTest {
    static AtomicInteger atomicInteger = new AtomicInteger();
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            System.out.println(atomicInteger.compareAndSet(0, 5));
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicInteger.compareAndSet(6, 10));
        }).start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName() + "----" + atomicInteger.compareAndSet(5, 6));
    }
}

CAS缺点：
缺点：
1、循环(自旋)开销很大！
2、内存操作，每次只能保证一个共享变量的原子性！
3、出现ABA 问题。
那么怎么解决ABA问题呢？加上版本号或者时间戳，原子引用。

package com.example.springboot.test.juc.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class AtoReferTest {
    public static void main(String[] args) {
        AtomicStampedReference reference = new AtomicStampedReference(1,1);
        new Thread(()->{
            int stamp = reference.getStamp();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "当前stamp的值：" + stamp);
            System.out.println(reference.compareAndSet(1, 5, reference.getStamp(), reference.getStamp() + 1));
            System.out.println(reference.compareAndSet(5, 10, reference.getStamp(), reference.getStamp() + 1));
        },"A").start();
        new Thread(()->{
            int stamp = reference.getStamp();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "当前stamp的值：" + stamp);
//            System.out.println(reference.compareAndSet(10, 15, reference.getStamp(), reference.getStamp() + 1));
            System.out.println(reference.compareAndSet(10, 15, stamp, stamp + 1));
        },"B").start();

    }
}

线程A和B先获取到版本号，然后A执行了更新，此时B也按照此版本更新，虽然旧值和期望值正确，但是版本号不对，所以更新失败。

死锁

死锁发生在互抢资源时，当一个线程拿到锁A，去拿锁B，而另一个线程拿到锁B，去拿锁A时，就发生互相抱着锁去抢别人的锁，就发生了死锁。

package com.example.springboot.test.juc.deadLock;

import java.util.concurrent.TimeUnit;

public class DeadLockTest {
    public static void main(String[] args) {
        String lockA = "a";
        String lockB = "b";
        new Thread(new test(lockA,lockB)).start();
        new Thread(new test(lockB,lockA)).start();
    }
}

class test implements Runnable{
    String lockA;
    String lockB;
    public test(String lockA,String lockB){
        this.lockA = lockA;
        this.lockB = lockB;
    }
    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "拿到了锁" + lockA + ",想拿到锁" + lockB);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "想拿到锁" + lockB);
            }
        }
    }
}

当死锁发生时，使用jprofiler工具进行分析，idea安装插件，并配置启动，就能分析当前程序发生的死锁。

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

  • 【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高并发编程详解系列-深入理解Thread构造 nihui123 高并发Java高并发Java高并发
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
  • Java高并发编程详解系列-Balking设计模式 nihui123 高并发设计模式java编程语言
    导语  在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式  在餐厅吃饭的时
  • Java高并发编程详解系列-Future设计模式 nihui123 高并发Java高并发Future高并发
    导语  假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
  • Java 并发编程：Java 线程池的介绍与使用 栗筝i 栗筝i的Java技术栈#Java基础栗筝i的Java技术栈Java基础Java并发Java线程池
    大家好，我是栗筝i，这篇文章是我的“栗筝i的Java技术栈”专栏的第024篇文章，在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验，并希望进一步完善自己对整个Java技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同
  • Python 课程8-多线程编程和多进程编程 可愛小吉 Python教學python开发语言threadingmultiprocessing
    前言在现代编程中，处理并发任务是提高程序性能的关键之一。Python提供了多线程（threading）和多进程（multiprocessing）两种方式来实现并发编程。多线程适用于I/O密集型任务，而多进程则更适合CPU密集型任务。通过这两种技术，你可以高效地处理大规模数据、加速程序执行并优化资源利用。在本篇详细教程中，我们将讨论如何使用Python的threading模块实现多线程，以及如何使用
  • Java并发复习 vd_vd Java并发安全容器java开发语言
    Java基础1.为什么要使用并发编程？一般我们工作的电脑都有多核，我们创建多个线程，然后操作系统可以将多个线程分配给不同的CPU去执行，每个CPU执行一个线程，这样就提高了CPU使用效率。在网络购物中，我们买了一个东西的同时，需要减库存，生成订单等等这些操作，就可以进行拆分利用多线程的技术完成。面对复杂业务模型，并行程序串行会比程序更适应业务需求，而并发编程更能吻合这种业务拆分。->充分利用多核C
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结 lzhlizihang java设计模式
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
  • 多线程的使用--＞5：并发编程的特性 路ZP java开发语言
    目录1.并发编程特性：2.并发编程的特性之一：原子性3.并发编程的特性之一：可见性3.1JVM内存模型3.2JMM（Java内存模型）4.并发编程的特性之一：有序性1.并发编程特性：多线程是一种程序开发或设计环境并发编程是一种程序设计概念或设计目标，在多线程开发环境中，同一系列的程序设计与机制的使用，确保多线程开发环境是稳定的，快速的，性能优秀的。并发编程具有3个特征原子性可见性有序性在多线程开发
  • 【Python系列】异步任务的终止 Kwan的解忧杂货铺@新空间代码工作室 s2Pythonpython开发语言
    欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
  • 浅谈C#之线程锁 CN.LG C#jvm开发语言c#
    一、基本介绍锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程获得了锁时，其他线程将被阻塞，直到该线程释放了锁。在并发编程中，多个线程同时访问共享资源可能导致数据竞争和不确定的行为。锁可以确保在任意时刻只有一个线程可以访问共享资源，从而避免竞态条件和数据不一致性问题。二、锁的作用原理锁的作用原理通常涉及到内部的互斥机制。当一个线程获得锁时，它会将锁标记为已被占用，其他线程尝试获取该锁时
  • 【Python系列】使用切片移动元素位置 Kwan的解忧杂货铺@新空间代码工作室 s2Pythonpython开发语言
    欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
  • Java 入门指南：Java 并发编程 —— 同步工具类 Semephore（信号量） ZachOn1y Javajava开发语言intellij-idea个人开发团队开发java-ee
    文章目录同步工具类Semephore核心功能限制并发访问量公平与非公平策略灵活性与适应性常用方法使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。SemephoreSemap
  • Java 入门指南：Java 并发编程 —— 同步工具类 CountDownLatch（倒计时门闩） ZachOn1y Javajava后端个人开发java-ee团队开发
    文章目录同步工具类CountDownLatch常用方法使用步骤适用场景使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。CountDownLatchCountDownLatc
  • 锁之synchronized 与volatile lock的异同 追梦的鱼儿 java锁synchronizedvolatileLock
    目录synchronized特性用法使用场景synchronized的优缺点优点缺点volatile特性用法使用场景Lock特性用法使用场景总结相同点不同点synchronized关键字是Java提供的用于解决并发编程中数据一致性问题的重要工具。它通过锁机制确保在同一时刻只有一个线程能够执行被同步的方法或代码块，从而实现互斥访问。尽管synchronized使用简单且可靠，但在高并发场景下可能会带
  • Go Web 编程 PDF book_longker 资源golangpdf开发语言
    GoWeb开发必读:《BuildingWebApplicationswithGo》PDF资源分享找寻良久,终于寻得这本珍贵资源!现在我免费分享给大家你是否正在学习Go语言开发Web应用?是否想要提升Go并发编程能力?这本书绝对不容错过!关于这本书《BuildingWebApplicationswithGo》是一本非常实用的GoWeb开发指南:以构建网络论坛为案例,全面讲解GoWeb开发️深入剖析请
  • Java并发编程：线程生命周期 乐只乐之 Java并发编程java职场和发展后端
    Java并发编程专栏文章收录于Java并发编程专栏线程生命周期  线程是Java并发编程的核心概念，理解线程生命周期对于编写高效的并发程序至关重要。本文将详细介绍Java线程的六种状态以及状态之间的转换关系，帮助读者更好地理解线程的行为。  在Java中JVM将线程按照生命周期划分为了四大种类：运行、等待、阻塞和结束，其中运行分为就绪（READY）和运行中中（RUNNING），阻塞分为等待（WAI
  • JAVA中的线程池说明一 Petrichor-瑾 JavaEEjava开发语言
    系列文章JAVA中的线程池说明一JAVA中的线程池说明二目录1.为什么需要线程池?2.什么是线程池?3.标准库中的线程池4.实现自定义线程池1.为什么需要线程池?线程的存在意义在于解决并发编程中进程开销过大的问题，因此引入了线程，也被称为"轻量级线程"。相比于创建进程，创建线程更加高效；同样地，销毁线程比销毁进程更高效，调度线程比调度进程更高效。在许多情况下，使用多线程可以替代进程来实现并发编程。
  • Java多线程：深入探索与详细解析 m0_63550220 java开发语言
    1.基础概念与重要性在Java编程中，多线程是并发编程的基石，它允许应用程序同时执行多个任务。这种能力不仅提高了程序的执行效率，还增强了其响应性和用户界面的流畅性。随着现代计算机系统的多核化趋势，多线程编程变得越来越重要，因为它能够充分利用硬件资源，提升程序的总体性能。线程（Thread）：作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线
  • 【Python系列】中位数计算 Kwan的解忧杂货铺@新空间代码工作室 s2Pythonpython开发语言
    欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
  • Elasticsearch——配置详解 smart哥 elasticsearch专题elasticsearch搜索引擎
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
  • 模式转变-并行编程方面的设计注意事项 guoxiaoqian8028 并行计算
    本文以VisualStudio工具的预发布版为基础。文中的所有信息均有可能发生变更。本文将介绍以下内容：并行计算并发编程性能提高本文使用了以下技术：多线程目录并发和并行结构化多线程数据并行性数据流数据并行性单程序，多数据并发数据结构总结从1986到2002年，微处理器的性能每年提高了52%。这一惊人的技术进步源自晶体管成本依据摩尔法则不断地缩减，以及处理器厂商在工程方面的出色表现。微软的研究员Ji
  • 函数式编程-Stream流 码农OvO 开发语言java
    函数式编程-Stream流1.概述1.1好处大数量下处理集合效率高代码可读性高消灭嵌套1.2函数式编程思想1.2.1概念面向对象思想需要关注用什么对象完成什么事情。而函数式编程思想就类似于我们数学中的函数。它主要关注的是对数据进行了什么操作。1.2.2优点代码简洁接近自然语言，易于理解易于"并发编程"2.Lambda表达式2.1概述Lambda是Jdk8中的一个语法糖。它可以对某些匿名内部类的写法
  • 大厂高频面试题复习JAVA学习笔记-学习路线 addaduvyhup java开发语言
    对于应届生，要找到一份java工作，你得大概学会：java基础：javase、jvm、juc、gc、mysql、jdbc，计网计组Java微服务基础Maven→Gradle→Spring6→SpringMVC→MyBatis→MyBatisPlus→SSM->Redis7->SpringBoot2->SpringCloudjava微服务生态:Git-Docker-Elasticsearch→Zoo
  • 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
  • 【编程底层思考】JUC中CAS的底层操作系统的实现原理及ABA问题 Dylanioucn jvmjava开发语言
    一、何为CAS操作Java中的CAS操作，即Compare-And-Swap，是一种用于实现无锁编程的原子操作。在Java的java.util.concurrent.atomic包中，许多原子类都利用了CAS操作来保证复合操作的原子性。在底层操作系统层面，CAS通常由特定的CPU指令实现，这些指令能够检测内存中的值是否为预期值，并在条件满足的情况下，将其更新为新值。二、操作系统层面的CAS实现原理
  • 并发编程——线程的启动 不太自律的程序猿
    前言今天简单的讲一讲线程的启动start方法。如果对于线程的创建方式不太了解，推荐观看并发编程——认识java里的线程对于线程状态及其切换不了解的，推荐观看并发编程——Java线程的6种状态及切换线程的启动在并发编程——认识java里的线程中我们有讲过线程的创建，我们启动线程的时候使用的是start方法。那么我们就先来看看start方法，简单的附上一些源码：关于threadStatus源码：通过代
  • 《代码整洁之道》读书笔记 fsy351 java开发语言
    《代码整洁之道》读书笔记根据书名，可以知道这本书围绕“代码整洁”的思想和方法展开，但是个人认为，它不仅仅强调了代码整洁内容，更多的还包括代码测试、系统设计、并发编程的部分内容。全书共分为17个章节和2个附加章节。整本书的章节感觉编排有点杂乱，根据个人理解整理成如下结构图：概念整洁代码为何要有整洁代码？代码确然是我们最终用来表达需求的语言，代码永存糟糕的代码会毁灭一家公司PS：当前信息时代，软件是生
  • tomcat基础与部署发布 暗黑小菠萝 Tomcat java web
    从51cto搬家了，以后会更新在这里方便自己查看。 做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 一、Tomcat安装     安装方式：①运行.exe安装包      &n
  • 网站架构发展的过程 ayaoxinchao 数据库应用服务器网站架构
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
  • [信息与安全]数据库的备份问题 comsci 数据库
          如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题   如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢?    是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢?  &n
  • 使用maven tomcat plugin插件debug关联源代码 商人shang mavendebug查看源码tomcat-plugin
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 *配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
  • 大访问量高并发 oloz 大访问量高并发
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 要列出几点解决方案： 01、优化你的代码和查询语句，合理使用索引 02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 03、采用服务器集群、负载均衡分担大访问量高并发压力 04、数据读写分离 05、合理选用框架，合理架构(推荐分布式架构)。
  • cache 服务器 小猪猪08 cache
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 　　1.Cache   是怎么样工作的? 　　Cache   是分配在服务器上
  • mysql存储过程 香水浓 mysql
    Description:插入大量测试数据 use xmpl; drop procedure if exists mockup_test_data_sp; create procedure mockup_test_data_sp( in number_of_records int ) begin declare cnt int; declare name varch
  • CSS的class、id、css文件名的常用命名规则 agevs JavaScriptUI框架Ajaxcss
      CSS的class、id、css文件名的常用命名规则     (一)常用的CSS命名规则 　　头：header 　　内容：content/container 　　尾：footer 　　导航：nav 　　侧栏：sidebar 　　栏目：column 　　页面外围控制整体布局宽度：wrapper 　　左右中：left right
  • 全局数据源 AILIKES javatomcatmysqljdbcJNDI
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
  • MYSQL的随机查询的实现方法 baalwolf mysql
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
  • JAVA的getBytes()方法 bijian1013 javaeclipseunixOS
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！      String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： byte[] b_gbk = "
  • AngularJS中操作Cookies bijian1013 JavaScriptAngularJSCookies
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。         幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
  • [Maven学习笔记五]Maven聚合和继承特性 bit1129 maven
    Maven聚合   在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块： 1. 模型和数据持久化层user-core, 2. 业务逻辑层user-service以 3. web展现层user-web， user-service依赖于user-core user-web依赖于user-core和use
  • 【JVM七】JVM知识点总结 bit1129 jvm
      1. JVM运行模式 1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler
  • linux下查看nginx、apache、mysql、php的编译参数 ronin47
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 1、nginx [root@361way ~]# /App/nginx/sbin/nginx -V nginx: nginx version: nginx/
  • unity中运用Resources.Load的方法？ brotherlamp unity视频unity资料unity自学unityunity教程
    问：unity中运用Resources.Load的方法？ 答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 1、unity实时替换的物体即是依据环境条件
  • 线段树-入门 bylijinnan java算法线段树
    /** * 线段树入门 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i] * * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18 * @author lijinna
  • 全选与反选 chicony 全选
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>全选与反选</title>
  • vim一些简单记录 chenchao051 vim
    mac在/usr/share/vim/vimrc linux在/etc/vimrc   1、问：后退键不能删除数据，不能往后退怎么办？       答：在vimrc中加入set backspace=2   2、问：如何控制tab键的缩进？       答：在vimrc中加入set tabstop=4 (任何
  • Sublime Text 快捷键 daizj 快捷键sublime
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
  • php 引用(&)详解 dcj3sjt126com PHP
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容  复制代码代码如下: <?  $a="ABC";  $b =&$a;  echo
  • SVN中trunk,branches,tags用法详解 dcj3sjt126com SVN
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
  • 对软件设计的思考 e200702084 设计模式数据结构算法ssh活动
    软件设计的宏观与微观    软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
  • 同步、异步、阻塞、非阻塞 geeksun 非阻塞
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。   同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。   异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 实现：
  • Reverse SSH Tunnel 反向打洞實錄 hongtoushizi ssh
    實際的操作步驟： # 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port ssh -NfR 12345:localhost:22 [email protected] # 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器 ssh localhost -p 1
  • Hibernate中的缓存 Josh_Persistence 一级缓存Hiberante缓存查询缓存二级缓存
    Hibernate中的缓存   一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
  • 对象关系行为模式之延迟加载 home198979 PHP架构延迟加载
    形象化设计模式实战     HELLO!架构   一、概念 Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。     二、实现延迟加载 实现Lazy Load主要有四种方法：延迟初始化、虚
  • xml 验证 pengfeicao521 xmlxml解析
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 public static void testPattern() { // 含有非法字符的串 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
  • div设置半透明效果 spjich css半透明
    为div设置如下样式：   div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}        说明： 1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
  • 你真的了解单例模式么？ w574240966 java单例设计模式jvm
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。   一，单例模式的5中写法。（回字的四种写法，哈哈。）     1，懒汉式           （1）线程不安全的懒汉式 public cla
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他