Eugene03
Eugene03

Java多线程学习

1. 多线程

线程与任务的关系

脱离了任务的线程是没有意义的

线程对象是通过Thread类来创建的

任务是通过Runnable接口来定义的

1.继承Thread类

2.实现Runnable接口

3.实现Callable接口 （与Runnable的区别，可以拿到返回值）

Thread线程执行的流程

线程一定要指定任务吗？

Thread构造器：无参构造器就是不需要指定任务，有参构造器可以直接指定线程的任务

 public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }

创建线程对象时候直接传入它的任务

流程：

  1. 创建线程对象，同时指定任务
  2. 启动线程，start，就绪状态，等待获取CPU资源
  3. 一旦拿到CPU资源之后，就开始执行任务， 调用Thread的run方法
  public static void main( String[] args )
    {
       Thread thread = new Thread(() ->{
           for (int i = 0; i < 10; i++){
               System.out.println(i);
           }
       });
       thread.start();
    }

// Thread 的run方法
 @Override
    public void run() {
        if (target != null) {
            target.run(); // tager 传入的任务
        }
    }
Thread类中定义了一个Runnable tager成员变量，用来接受创建线程对象时，传入的任务
    1. 创建线程对象，传入任务
    2. 将任务赋值给tager成员变量
    3. 线程执行的时候，操作tager成员变量

实现多线程的两种形式对比

  1. 继承Thread ---- 继承的缺点在于直接把任务的实现写进了线程类当中，耦合度太高
public class MyThread extends Thread{
  
    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println("----MyThread" + i);
        }
    }
}

public class App 
{
    public static void main( String[] args )
    {
        MyThread thread = new MyThread();
        thread.start();

    }
}
  1. 实现接口Runnable — 实现接口的形式可以解决上述问题 实现解耦合
public class MyRunnable implements Runnable{
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println("myThread1:" + i);
        }
    }
}


public class MyRunnable2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println("myThread2:" + i);
        }
    }
}


public class App 
{
    public static void main( String[] args )
    {
        Runnable runnable1 = new MyRunnable();
        Runnable runnable2 = new MyRunnable2();

       Thread thread = new Thread(runnable1);
        thread.start();
        Thread thread1 = new Thread(runnable2);
        thread1.start();
    }
}

线程休眠

  1. 创建t1对象并启动

  2. t1休眠1秒

  3. 创建t2对象并启动

          Thread t1 = new Thread(() ->{
            for(int i = 0; i < 10; i++){
                System.out.println(1);
            }
        });
        t1.start();

        try {
            t1.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    Thread t2 = new Thread(()->{
        for(int i = 0; i < 10; i ++){
            System.out.println(2);
        }
    });
        t2.start();


结果先输出10个1 在输出10个2
    原因： sleep方法到底让哪个线程休眠
    不在于谁调用sleep 而在于slepp写在哪 与调用者无关  （sleep 是静态方法信息）
    
    放到t1里面 t1休眠
    放在t2里面 t2休眠

2. JUC并发 编程 Java-util-concurrent在并发编程中使用的工具包

1. Java多线程相关概念

  • 并发
    • 是在用一个实体类上的多个事件
    • 是在一台机器上同时处理多个任务， 同一时刻，其实是只有一个事情在发生
  • 并行
    • 是在不同实体上的多个事情
    • 是在多台处理器上同时处理多个任务
    • 同一时刻，大家都在做事情，你做你的，我做我的，但是我们都在做
  • 进程
    • 简单来说，在系统中运行的一个应用程序就是一个进程，每一个进程都有它自己的内存空间和系统资源
  • 线程
    • 也被称为轻量级进程，在同一个进程中会有1个或者多个线程是大多数操作系统进行时序调度的基本单元
  • 管程
    • 俗称Monitor(监视器) 也就是平时所说的锁
  • 用户线程 一般情况不做特别说明配置，默认为用户线程
  • 守护线程
    • 线程daemon属性 true表示守护线程，false表示用户线
    • 如果用户线程全部介绍意味着程序需要完成的业务操作已经结束了，守护线程随着JVM一同结束工作，
    • setDaemon(true)方法必须在start()之前设置，否则会报IllegelThreadStateException异常

2. FutureTask

基本实现使用， future+线程池异步多线程配合，能显著提高程序的执行效率


// 多线程/有返回值/异步任务
public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask<>(new MyThreadCall());
        Thread t1 = new Thread(futureTask, "t1");
        t1.start();
        System.out.println(futureTask.get());

    }

}

class MyThreadCall implements Callable {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public String call() throws Exception {
        System.out.println("come in call()");
        return "hello callable";
    }
}


// 结合线程池使用

public class FutureThreadPoolDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Long startTime = System.currentTimeMillis();

        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        FutureTask futureTask = new FutureTask<>(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "task over";
        });
        threadPool.submit(futureTask);

        FutureTask futureTask2 = new FutureTask<>(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "task2 over";
        });
        threadPool.submit(futureTask2);

        System.out.println(futureTask.get());
        System.out.println(futureTask2.get());


        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        Long end = System.currentTimeMillis();

        System.out.println("耗时" + (end - startTime));
        threadPool.shutdown();
    }

    public void m1() {
        // 3个任务 目前只有一个线程main处理，请问耗时多少

        Long startTime = System.currentTimeMillis();
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Long end = System.currentTimeMillis();

        System.out.println("耗时" + (end - startTime));
        System.out.println(Thread.currentThread().getName());
    }
}
  1. 缺点1:
    1. get()阻塞 如果没有计算完成，那么将会造成阻塞，一般建议放在程序最后
    2. 假如不愿意等待很长时间，我希望过时不候，可以自动离开。
public class FutureAPIDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        FutureTask futureTask = new FutureTask<>(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "task over";
        });

        Thread thread = new Thread(futureTask, "t1");
		 thread.start();
//        System.out.println(futureTask.get()); // 会造成阻塞

        System.out.println(Thread.currentThread().getName() + "   " + "忙其他任务");


//        System.out.println(futureTask.get()); // 等待返回值才结束程序
        System.out.println(futureTask.get(3, TimeUnit.SECONDS)); // 等待3秒，如果没收到返回值，将抛出异常时间超时TimeoutException，并结束程序
    }
}

  1. 缺点2 isDone 轮询

    1. 轮询的方式会浪费无谓的CPU资源，而且也不见得能及时地得到计算结果，
    2. 如果想要异步获取结果，通过都会以轮询的方式去获取结果，尽量不要阻塞
    public class FutureAPIDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask<>(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "task over";
        });

        Thread thread = new Thread(futureTask, "t1");
        thread.start();

        System.out.println(Thread.currentThread().getName() + "   " + "忙其他任务");
        while (true) {
            if (futureTask.isDone()) {
                System.out.println(futureTask.get());
                break;
            } else {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("还没好");
            }
        }

    }
}

结论： Future对于结果的获取不是很友好，只能通过阻塞或者轮询的方式得到任务的结果

3. CompletableFuture

引言：

  1. 对于简单的业务场景使用Future完全OK
  2. 回调通知：
    1. 应对Future的完成时间，完成了可以告诉我，也就是我们的回调通知
    2. 通过轮询的方式去判断任务是否完成这样非常占CPU并且代码也不优雅
  3. 创建异步任务，Future与线程池的配合，
  4. 多个任务前后依赖可以组合处理
    1. 想将多个异步任务的计算结合组合起来，后一个异步任务的计算结果需要前一个异步任务的值
    2. 将两个或多个异步计算合成一个异步计算，这几个异步计算相互独立，同时后面这个又依赖前一个处理的结果。
  5. 对计算结果选最快 — 当Future集合中某个任务最快介绍时，返回结果，返回第一名处理结果
CompletableFuture 创建方法  // 官方建议，不推荐使用new CompletableFuture() 直接创建
没有指定Executor的方法，直接使用默认的ForkJoinPool.commonPool()作为它的线程池执行异步代码
如果指定线程池，则使用我们自定义的或者特别指定的线程池执行异步代码
    1. 无返回值 无指定线程池，使用默认的线程池
    public static CompletableFuture runAsync(Runnable runnable) {
        return asyncRunStage(ASYNC_POOL, runnable);
    }
	2. 无返回值，指定线程池
    public static CompletableFuture runAsync(Runnable runnable,
                                                   Executor executor) {
        return asyncRunStage(screenExecutor(executor), runnable);
    }
	3. 有返回值，无指定线程池，使用默认的线程池
    public static  CompletableFuture supplyAsync(Supplier supplier) {
        return asyncSupplyStage(ASYNC_POOL, supplier);
    }

    4. 有返回值，指定线程池
    public static  CompletableFuture supplyAsync(Supplier supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }

// 补充：
CompletableFuture.get() 需要抛出异常，
CompletableFuture.join() 不需要抛出异常，


// 案例1
public class CompletableFutureBuildDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 官方建议，不推荐使用new CompletableFuture() 直接创建

        CompletableFuture completableFuture = CompletableFuture.runAsync(() -> {
            // 不指定线程池，得到的名字ForkJoinPool.commonPool-worker-19
            System.out.println(Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        // 结果输出为null
        System.out.println(completableFuture.get());
    }
}
// 案例2 
public class CompletableFutureBuildDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Executor executor = Executors.newFixedThreadPool(3);
        CompletableFuture completableFuture = CompletableFuture.runAsync(() -> {
            // 指定线程池 输出名字为pool-1-thread-1
            System.out.println(Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, executor);
        // 结果输出为null
        System.out.println(completableFuture.get());
    }
}
// 案例3
public class CompletableFutureBuildDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {
            // 没有指定线程池线程名字为ForkJoinPool.commonPool-worker-19
            System.out.println(Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "this is supplyAsync";
        });
       //  得到返回结果this is supplyAsync
        System.out.println(completableFuture.get());
    }
}

// 案例4
public class CompletableFutureBuildDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Executor executor = Executors.newFixedThreadPool(3);
        CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> {
              // 指定线程池 输出名字为pool-1-thread-1
            System.out.println(Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "this is supplyAsync";
        }, executor);
     //  得到返回结果this is supplyAsync
        System.out.println(completableFuture.get());
    }
}

 
  
通用功能演示，减少阻塞和轮询
 
  
// 线程返回结果是进入  传入线程返回的值和异常如下案例
public CompletableFuture whenComplete(
        BiConsumer action) {
        return uniWhenCompleteStage(null, action);
}
// 线程发生异常时进入， 用例如下
public CompletableFuture exceptionally(
        Function fn) {
        return uniExceptionallyStage(fn);
}


 
  

// 案例1 使用默认线程池
public class CompletableFutureUserDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture supplyAsync = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "----come in");
            int result = ThreadLocalRandom.current().nextInt(10);
            try {
                TimeUnit.MILLISECONDS.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("-----1秒后出结果:" + result);
            return result;
        }).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("-------计算完成，更新updateValue:-------" + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            System.out.println("异常情况处理：" + e.getCause() + "\t" + e.getMessage());
            return null;
        });

        System.out.println(Thread.currentThread().getName() + "---- 忙别的");

        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭，在暂停3秒种线程（与用户进程和守护进程相关）
        try {
            TimeUnit.MILLISECONDS.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}    
    
// 案例2  使用自定义线程池
public class CompletableFutureUserDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // ExecutorService Executor的子类
        ExecutorService executor = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture supplyAsync = CompletableFuture.supplyAsync(() -> {
                System.out.println(Thread.currentThread().getName() + "----come in");
                int result = ThreadLocalRandom.current().nextInt(10);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("-----1秒后出结果:" + result);
                return result;
            }, executor).whenComplete((v, e) -> {
                if (e == null) {
                    System.out.println("-------计算完成，更新updateValue:-------" + v);
                }
            }).exceptionally(e -> {
                e.printStackTrace();
                System.out.println("异常情况处理：" + e.getCause() + "\t" + e.getMessage());
                return null;
            });

            System.out.println(Thread.currentThread().getName() + "---- 忙别的");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
        

        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭，在暂停3秒种线程（与用户进程和守护进程相关） 使用自定义线程池无需卡主主线程
//        try {
//            TimeUnit.MILLISECONDS.sleep(3000);
//        } catch (InterruptedException e) {
//            throw new RuntimeException(e);
//        }
    }
}
// 案例三 异常处理
public class CompletableFutureUserDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // ExecutorService Executor的子类
        ExecutorService executor = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture supplyAsync = CompletableFuture.supplyAsync(() -> {
                System.out.println(Thread.currentThread().getName() + "----come in");
                int result = ThreadLocalRandom.current().nextInt(10);
                // 创造异常
                if (result > 5) {
                    int i = 10 / 0;
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("-----1秒后出结果:" + result);
                return result;
            }, executor).whenComplete((v, e) -> {
                if (e == null) {
                    System.out.println("-------计算完成，更新updateValue:-------" + v);
                }
            }).exceptionally(e -> {
                e.printStackTrace();
                System.out.println("异常情况处理：" + e.getCause() + "\t" + e.getMessage());
                return null;
            });

            System.out.println(Thread.currentThread().getName() + "---- 忙别的");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}
输出结果：
    pool-1-thread-1----come in
main---- 忙别的
异常情况处理：java.lang.ArithmeticException: / by zero	java.lang.ArithmeticException: / by zero
java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
	... 3 more

 
  
CompletableFuture的优点
 
  
     
   
  • 异步任务介绍后，会自动回调某个对象的方法；
    •  
   
  • 主线程设置好回调后，不再关心异步任务的执行，异步任务之间可以顺序执行
    •  
   
  • 异步任务出错时，会自动回调某个对象的方法；
    •  
  
 
  
案例实战
 
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S2MZ4DDv-1685244934310)(C:\Users\56964\AppData\Roaming\Typora\typora-user-images\1685107704454.png)]
 
  
/**
 * 1需求说明
 * 1.1同一款产品，同时搜索出同款产品在各大电商平台的售价;
 * 1.2同一款产品，同时搜索出本产品在同一个电商平台下，各个入驻卖家售价是多少
 * 2输出返回:
 * 出来结果希望是同款产品的在不同地方的价格清单列表，返回一个List《mysql》 in jd price is 88.05
 * 《mysql》 in dangdang price is 86.11《mysql》 in taobao price is 90.43
 * 3解决方案,比对同一个商品在各个平台上的价格，要求获得一个清单列表，1 step by step,按部就班,查完京东查淘宝,查完淘宝查天猫…...…
 * 2all in 万箭齐发，一口气多线程异步任务同时耸询。。 o o o
 *
 * @author cyh
 * @Classname CompletableFutureMallDemo
 * @Description TODO
 * @Version 1.0.0
 * @Date 2023/5/26 21:17
 **/
public class CompletableFutureMallDemo {
    static List netMallList = Arrays.asList(
            new NetMall("jd"),
            new NetMall("dangdang"),
            new NetMall("taobao")
    );

    /**
     * 一家家搜索 step by step
     *
     * @param list
     * @param produceName
     * @return
     */
    public static List getPrice(List list, String produceName) {
        return list
                .stream()
                .map(netMall ->
                        String.format(produceName + "in %s price is %.2f",
                                netMall.getNetMallName(),
                                netMall.calcPrice(produceName)))
                .collect(Collectors.toList());
    }

    /**
     * all in 万箭齐发，一口气多线程异步任务同时查询
     *
     * @param list
     * @param produceName
     * @return
     */
    public static List getPriceByCompletableFuture(List list, String produceName) {
        return list
                .stream()
                .map(netMall -> CompletableFuture.supplyAsync(() -> String.format(produceName + "in %s price is %.2f",
                        netMall.getNetMallName(),
                        netMall.calcPrice(produceName))))
                .collect(Collectors.toList())// 先获取到List>
                .stream() // 在对List>进行流处理获取join()得到List
                .map(CompletableFuture::join)
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        List stringList = getPrice(netMallList, "MySQL");
        stringList.forEach(System.out::println);
        long endTime = System.currentTimeMillis();
        System.out.println("-----step by step costTime:" + (endTime - startTime) + "毫秒");

        long startTime2 = System.currentTimeMillis();
        List stringList2 = getPriceByCompletableFuture(netMallList, "MySQL");
        stringList2.forEach(System.out::println);
        long endTime2 = System.currentTimeMillis();
        System.out.println("-----all in costTime:" + (endTime2 - startTime2) + "毫秒");
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
class NetMall {

    private String netMallName;

    public Double calcPrice(String productName) {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return ThreadLocalRandom.current().nextDouble() * 2 + productName.charAt(0);
    }
}


返回值：    
MySQLin jd price is 78.70
MySQLin dangdang price is 77.58
MySQLin taobao price is 77.41
-----step by step costTime:3050毫秒
MySQLin jd price is 77.39
MySQLin dangdang price is 77.71
MySQLin taobao price is 78.30
-----all in costTime:1012毫秒


 
  
CompletableFuture常用计算
 
  
1. 获取结果
 
  
public T get();
publie get(long timeout, TimeUnit unit);
publie T join();
public T getNow(T valueIfAbsent); 获取时线程未计算完成返回valueIfAbsent， 获取时已经计算完成则正常返回值，不会阻塞

 
  
2. 主动触发计算
 
  
public boolean complete(T value); 是否打断get方法立即返回括号值 无需抛出异常 线程计算未完成时，使用打断线程返回true，调用join()获取到的值为value， 线程计算完成调用方法，返回false，调用join()时返回线程返回的值

 
  
public class CompletableFutureAPIDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return "abc";
        });
        System.out.println(future.get()); // 阻塞输出 abc
        System.out.println(future.get(2L, TimeUnit.SECONDS)); //2秒内获取不到抛出异常，获取到输出abc
        System.out.println(future.join()); // 无需处理异常。阻塞获取输出abc
        try {
            TimeUnit.MILLISECONDS.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(future.getNow("xxxxx")); // 调用时如果还没有计算完成，则输入xxxxx, 如果有返回值则输出abc
        System.out.println(future.complete("completeValue") + "\t" + future.join()); // 是否打算计算，是返回true， join返回completeValue 否返回false， join得到abc
    }
}

 
  
3. 对计算结果进行处理
 
  
thenApply 计算结果存在依赖关系，这两个线程串行化
    异常相关：由于存在依赖关系（当前步错，不走下一步）， 当前步骤有异常的话就叫停
public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture.supplyAsync(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return 1;
            }, executorService).thenApply(f -> f + 2).thenApply(f -> f + 3).whenComplete((v, e) -> {
                if (e == null) {
                    System.out.println(v);
                }
            }).exceptionally(e -> {
                e.printStackTrace();
                return null;
            });

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

    }
}


handle 计算结果存在依赖关系，这两个线程串行化， 正常情况下 与thenApply一致
    异常相关： 有异常也可以往下一步走，根据带的异常可以进入下一步处理
    public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture.supplyAsync(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return 1;
            }, executorService).handle((f, e) -> {
                int i = 10 / 0;
                return f + 2;
            }).handle((f, e) -> {
                if (e != null) {
                    return 3;
                }
                return f + 3;
            }).whenComplete((v, e) -> {
                if (e == null) {
                    System.out.println(v);
                }
            }).exceptionally(e -> {
                e.printStackTrace();
                return null;
            });

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

    }
}

 
  
4.对计算结果进行消费
 
  
thenAccept 接受任务的处理结果，并消费处理，无返回结果
    public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture.supplyAsync(() -> {
                        try {
                            TimeUnit.MILLISECONDS.sleep(1000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        return 1;
                    }, executorService)
                    .thenApply(f -> f + 2)
                    .thenApply(f -> f + 3)
                    .thenAccept(System.out::println);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

    }
}

 
  
对比：
 
  
     
   
  • thenRun(Runable runnable) 
    
       
     
    • 任务A执行完成执行任务B，并且B不需要A的结果
      •  
    
     
    •  
   
  • thenAccpet(Consumer action) 
    
       
     
    • 任务A执行完执行B，B需要A的结果，但是任务B无返回值
      •  
    
     
    •  
   
  • thenApply(Function fn) 
    
       
     
    • 任务A执行完执行任务B，B需要A的结果，同时任务B有返回值
      •  
    
     
    •  
  
 
  
5. CompletableFuture和线程池的说明
 
  
     
   
  1. 以thenRun和thenRunAsync为例，有什么区别 
    
       
     
    1. 没有传入自定义线程池，都用默认的线程池ForkJoinPool;
      2.  
     
    2. 传入了一个自定义的线程池 
      
         
       
      1. 如果执行第一个任务的时候，传入了一个自定义的线程池；
        2.  
       
      2. 调用thenRun方法执行第二个任务时，则第二个任务和第一个任务是共用一个线程池。
        3.  
       
      3. 调用thenRunAsync执行第二个任务时，则第一个任务使用的是你自己传入的线程池，第二个任务使用的是ForkJoin线程池
        4.  
      
       
      3.  
     
    3. 备注： 
      
         
       
      1. 有可能处理太快，系统优化切换原则，直接使用main线程处理
        2.  
       
      2. 其他如：thenAccept和thenAccpetAsync，thenApply和thenApplyAsync等，他们之前的区别也是同理。
        3.  
      
       
      4.  
    
     
    2.  
  
 
  
6. 对计算速度的选用
 
  
applyToEither  
public class CompletableFuturePoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        try {
            CompletableFuture aComeIn = CompletableFuture.supplyAsync(() -> {
                System.out.println("A come in");
                try {
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return "resultA";
            }, executorService);

            CompletableFuture bComeIn = CompletableFuture.supplyAsync(() -> {
                System.out.println("b come in");
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return "resultB";
            }, executorService);

            CompletableFuture result = aComeIn.applyToEither(bComeIn, f -> f + " is winner");

            System.out.println(result.join());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}


 
  
7. 对计算结果进行合并
 
  
两个CompletionStage任务都完成后，最终能把两个任务的结果一起交给thenCombine来处理，先完成的先等着，等待其他分支任务。
public class CompletableFutureAPIDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture supplyAsync1 = CompletableFuture.supplyAsync(() -> {
                System.out.println("1 come int");
                try {
                    TimeUnit.MILLISECONDS.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return 10;
            }, executorService);


            CompletableFuture supplyAsync2 = CompletableFuture.supplyAsync(() -> {
                System.out.println("2 come int");
                try {
                    TimeUnit.MILLISECONDS.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                return 30;
            }, executorService);

            CompletableFuture combine = supplyAsync1.thenCombine(supplyAsync2, (x, y) -> {
                System.out.println("两个结果合并");
                return x + y;
            });

            System.out.println(combine.join());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

    }
}


 
  
4. 多线程锁
 
  
1. 悲观锁
 
  
     
   
  • 介绍： 认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改
    •  
   
  • synchronized关键字和lock的实现类都是悲观锁
    •  
   
  • 适合场景： 
    
       
     
    • 写操作多的场景，先加锁可以保证写操作时数据正确，显式的锁定之后再操作同步资源
      •  
    
     
    •  
  
 
  
2. 乐观锁
 
  
     
   
  •  
    介绍：认为自己在使用数据时不会有别的线程修改数据或者资源，所以不会添加锁
     
    •  
   
  •  
    在Java中是通过使用无锁编程来实现，只是在更新数据的时候去判断，之前有没有别的线程更新了这个数据
     
    如果这个数据没有被更新，当前线程将自己修改的数据成功写入。
     
    如果这个数据已经被其他线程更新，则根据不同的实现方式执行不用的操作，比如放弃修改，重试抢锁等等
     
    •  
   
  •  
    判断规则：
     
    
       
     
    • 版本号机制Version
      •  
     
    • 最常用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现
      •  
    
     
    •  
   
  •  
    适合场景：
     
    
       
     
    • 读操作多的场景，不加锁的特点能够使其读操作的性能大幅度提升
      •  
     
    • 乐观锁则直接去操作同步资源，是一种无锁算法
      •  
    
     
    •  
  
 
  
锁相关的8种案例演示code
 
  
/**
 * 题目： 谈谈对多线程锁的理解，8锁案例说明
 * 口诀： 线程， 操作， 资源类
 * 8锁案例说明：
 * 1 标准两个a, b线程,先打印发邮件还是短信 email sms
 * 2. sendEmail方法加入暂停3秒钟，请问先打印邮件还是短信 email sms
 * 3. 添加一个普通的hello方法，请问先打印邮件还是hello hello email
 * 4. 有两部手机，请问先打印手机还是邮件 sms email
 * 5. 有两个静态同步方法，有一部手机，请问先打印手机还是邮件 email sms
 * 6. 有两个静态同步方法，有两部手机，请问先打印手机还是邮件 email sms
 * 7. 有一个静态同步方法，有一个普通同步方法，有一部手机，请问先打印手机还是邮件 sms email
 * 8. 有一个静态同步方法，有一个普通同步方法，有两部手机，请问先打印手机还是邮件  sms email
 * 

 * 

 * 

 * 笔记总结：
 * 1-2
 * * * 一个对象里面如果有多个synchronized方法，某个时刻内，只要一个线程去调用其中一个synchronized方法了
 * * * 其它线程都只能等待，换句话说，弄一个时刻内，只能有唯一的一个线程去访问这些synchronized方法
 * * * 锁的是当前对象的this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
 * 3-4
 * * * 加个普通方法后发现与同步锁无关
 * * * 换成两个对象后，不是同一把锁了
 * 5-6 都换成静态同步方法后，变成了类锁
 * * * 三种synchronized锁的内容有一些差别
 * * * 对于普通同步方法，锁的是当前实例对象，通常指this，具体的一部部手机，所有的普通同步方法用的都是同一把锁->实例对象本身本身
 * * * 对于静态同步方法，锁的是当前类Class对象，如Phone.class唯一的一个模板
 * * * 对于同步方法块，锁的是synchronized括号内的对象
 * 7-8
 * * * 当一个线程试图访问同步代码时它首先必须得到锁，正常退出或者抛出异常时必须释放锁
 * * * 所有的普通同步方法用的都是同一把锁--实例对象本身，就是new出来的具体实例对象本身，本类this
 * * * 也就是说，如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获得锁
 * * *
 * * * 所有的静态同步方法用的也是 同一把锁--类本身，就是唯一模板Class
 * * * 具体实例对象this和唯一模板Class, 这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的
 * * * 但是一旦一个静态同步方法获得锁后，其他的静态同步方法都必须等待该方法释放锁后才能获得锁
 */
public class Lock8Demo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone1 = new Phone();
        new Thread(phone::sendEmail, "a").start();

        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() ->{
            phone.sendSms();
            phone1.hello();
            
        }, "b").start();
    }
}

class Phone {
    public synchronized void sendEmail() {

        try {
            TimeUnit.MILLISECONDS.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("-----sendEmail");
    }

    public synchronized void sendSms() {
        System.out.println("-----sendSms");
    }

    public static synchronized void sendEmail() {

        try {
            TimeUnit.MILLISECONDS.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("-----sendEmail");
    }

    public static synchronized void sendSms() {
        System.out.println("-----sendSms");
    }
    public void hello() {
        System.out.println("---------hello");
    }
}

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,学习,jvm)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 2019-12-22-22:30
                        涓涓1016

                        
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 阶段总结反思
                        轻争

                        
    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • 展现思维导图魅力，不断挖掘人生宝藏
                        思维导图讲师Mandy

                        
    第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
    
                    
    • 
                    
  • 2019-3-23晨间日记
                        红红火火小耳朵

                        
    今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
    
                    
    • 
                    
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
    
                    
    • 
                                
  • 对于规范和实现，你会混淆吗？
                                    yangshangchuan
HotSpot
                                    
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： 
 
 JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
    
                                
    • 
                                
  • android 网络
                                    百合不是茶
网络
                                    
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat 
  
服务器代码;  servlet的使用需要在xml中注册 
package servlet;

import java.io.IOException;
import java.util.Arr
    
                                
    • 
                                
  • [读书笔记]读法拉第传
                                    comsci
读书笔记
                                    
     
 
      1831年的时候,一年可以赚到1000英镑的人..应该很少的... 
 
      要成为一个科学家,没有足够的资金支持,很多实验都无法完成 
 
      但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
    
                                
    • 
                                
  • 随机数的产生
                                    沐刃青蛟
随机数
                                    
    c++中阐述随机数的方法有两种： 
  
一是产生假随机数（不管操作多少次，所产生的数都不会改变） 
  
       这类随机数是使用了默认的种子值产生的，所以每次都是一样的。 
  
	//默认种子
	for (int i = 0; i < 5; i++)
	{
		cout<<
    
                                
    • 
                                
  • PHP检测函数所在的文件名
                                    IT独行者
PHP函数
                                    
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 
代码： 
     
[php]   
view plain 
copy    
 
 // Filename: functions.php    
 <?php&nbs
    
                                
    • 
                                
  • 银行各系统功能简介
                                    文强chu
金融
                                    
    银行各系统功能简介     　   业务系统   核心业务系统     业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等       清分清算系统     以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程       国际结算系
    
                                
    • 
                                
  • Python学习1(pip django 安装以及第一个project)
                                    小桔子
pythondjangopip
                                    
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 
第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 
第二部：解压这个压缩文件，会看到一个setup.p
    
                                
    • 
                                
  • php 数组
                                    aichenglong
PHP排序数组循环多维数组
                                    
    1 php中的创建数组 
 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 
2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 
 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 
 $numbers=range(1,10,
    
                                
    • 
                                
  • 安装python2.7
                                    AILIKES
python
                                    
    安装python2.7 
1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 
2、复制解压 
#mkdir -p /opt/usr/python 
#cp  /opt/soft/Python-2
    
                                
    • 
                                
  • java异常的处理探讨
                                    百合不是茶
JAVA异常
                                    
    //java异常  
/* 
1，了解java 中的异常处理机制，有三种操作 
a,声明异常  
b,抛出异常  
c,捕获异常 
2，学会使用try-catch-finally来处理异常 
3，学会如何声明异常和抛出异常 
4，学会创建自己的异常 
  
*/ 
  
//2，学会使用try-catch-finally来处理异常 
  
    
                                
    • 
                                
  • getElementsByName实例
                                    bijian1013
element
                                    
    实例1： 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/x
    
                                
    • 
                                
  • 探索JUnit4扩展：Runner
                                    bijian1013
java单元测试JUnit
                                    
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。 
        文章地址：http://www.blogjava.net/jiangshachina/archive/20
    
                                
    • 
                                
  • [MongoDB学习笔记二]MongoDB副本集
                                    bit1129
mongodb
                                    
    1. 副本集的特性 
  1)一台主服务器(Primary),多台从服务器(Secondary) 
  2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作 
  3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来 
  
2
    
                                
    • 
                                
  • 【Spark八十一】Hive in the spark assembly
                                    bit1129
assembly
                                    
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 
 
  1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
    
                                
    • 
                                
  • Nginx问题定位之监控进程异常退出
                                    ronin47

                                    
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 
1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 
比如，这是一个异常退出的情况： 
$grep signal error.log

2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
    
                                
    • 
                                
  • No grammar constraints (DTD or XML schema).....两种解决方法
                                    byalias
xml
                                    
    方法一：常用方法   关闭XML验证 
工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 
 
方法二：（个人推荐） 
添加 内容如下 
<?xml version=
    
                                
    • 
                                
  • Netty源码学习-DefaultChannelPipeline
                                    bylijinnan
netty
                                    
    package com.ljn.channel;

/**
 * ChannelPipeline采用的是Intercepting Filter 模式
 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现
 * 
 * 下面对ChannelPipeline作一个模拟，只模拟关键代码：
 */
public class Pipeline {
 
    
                                
    • 
                                
  • MYSQL数据库常用备份及恢复语句
                                    chicony
mysql
                                    
      
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 
mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 
 
备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 
mysqldump -–add-drop-table -uusername -ppassword databasename > ba
    
                                
    • 
                                
  • 小白谈谈云计算--基于Google三大论文
                                    CrazyMizzz
Google云计算GFS
                                    
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。 
    我先说说GFS 
  &n
    
                                
    • 
                                
  • hadoop 平衡空间设置方法
                                    daizj
hadoopbalancer
                                    
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： 
<property> 
  <name>dfs.balance.bandwidthPerSec</name> 
    <value>10485760</value> 
    <description&g
    
                                
    • 
                                
  • Eclipse程序员要掌握的常用快捷键
                                    dcj3sjt126com
编程
                                    
       判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。     程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
    
                                
    • 
                                
  • Android学习之路
                                    dcj3sjt126com
Android学习
                                    
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 
以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 
下面说说我学习Android的感受，我学Android首先是看MARS的视
    
                                
    • 
                                
  • java 遍历Map的四种方法
                                    eksliang
javaHashMapjava 遍历Map的四种方法
                                    
    转载请出自出处： 
http://eksliang.iteye.com/blog/2059996 
 
package com.ickes;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
 * 遍历Map的四种方式

    
                                
    • 
                                
  • 【精典】数据库相关相关
                                    gengzg
数据库
                                    
    package C3P0; 
import java.sql.Connection; 
import java.sql.SQLException; 
import java.beans.PropertyVetoException; 
import com.mchange.v2.c3p0.ComboPooledDataSource; 
public class DBPool{       
    
                                
    • 
                                
  • 自动补全
                                    huyana_town
自动补全
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
    
                                
    • 
                                
  • jquery在线预览PDF文件，打开PDF文件
                                    天梯梦
jquery
                                    
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。 
  
核心代码 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
    
                                
    • 
                                
  • ViewPager刷新单个页面的方法
                                    lovelease
androidviewpagertag刷新
                                    
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
    
                                
    • 
                                
  • 利用按位取反（~）从复合枚举值里清除枚举值
                                    草料场
enum
                                    
    以 C# 中的 System.Drawing.FontStyle 为例。  
  
如果需要同时有多种效果， 
如：“粗体”和“下划线”的效果，可以用按位或（|） 
FontStyle style = FontStyle.Bold | FontStyle.Underline; 
  
如果需要去除 style 里的某一种效果， 
    
                                
    • 
                                
  • Linux系统新手学习的11点建议
                                    刘星宇
编程工作linux脚本
                                    
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 
 
　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
    
                                
    • 
                                
  • hibernate dao层应用之HibernateDaoSupport二次封装
                                    wangzhezichuan
DAOHibernate
                                    
    /** 
 * <p>方法描述:sql语句查询 返回List<Class> </p> 
 * <p>方法备注: Class 只能是自定义类 </p> 
 * @param calzz 
 * @param sql 
 * @return 
 * <p>创建人：王川</p> 
 * <p>创建时间：Jul
    
                                
    •