沉睡羊sleepysheep
沉睡羊sleepysheep

多线程的安全与应用

目录

 1.1进程与线程之间的区别与联系

 2-1 通过继承Thread类创建线程

2-2 选择练习 

 2-5 run方法和start方法的区别

​2-6 实现runnable方法接口创建线程

 2-7 选择练习

2-8 自由编程

 2-9 实现Callable接口创建线程

 2-10 线程的生命周期

 2-11 选择练习

3-1 初试线程同步并使用Synchronized实现线程同步

3-2 选择练习 

 3-3 Synchronized在不同场景下锁对象的区别

 3-4 选择练习

3-5 实现线程安全解决超卖现象

4-1 初识线程池及其基本应用

 4-2 线程池的四种类型

4-3 课程总结 

说明：本章的目的是弄明白在java中多线程程序开发有什么细节以及处理过程中有什么需要注意的地方。

 本章主要分为五个部分进行讲解

多线程的安全与应用_第1张图片

 1.1进程与线程之间的区别与联系

多线程的安全与应用_第2张图片

说明：程序就是一个静态的概念

当程序启动以后就会以进程的方式在操作系统的内存中进行驻留

多线程的安全与应用_第3张图片

说明：进程就是程序运行后在内存中的一个实例，进程的一个特性就是彼此之间相互隔离。

根据程序设计的需要有的程序是允许启动多个进程的。

每一个启动的进程在内存中都是独立存储和管理的。

两个记事本的进程彼此互不干扰，有的只允许启动一份，防止出现混乱。

 多线程的安全与应用_第4张图片

说明：进程的资源往往指的是内存文件这些东西，例如当迅雷运行时系统会为其分配128m的内存进行使用，其他的进程就不能对这128m内存进行读取或者写入的操作。这就是资源的隔离性。

 多线程的安全与应用_第5张图片

说明： 线程是进程内部一个一个要执行的任务，例如迅雷下载就是底层创建了3个线程，每一个线程都有一个任务去下载独自的文件，而且这些线程是可以并行执行的，为什么可以并行执行？我们稍后再说

多线程的安全与应用_第6张图片

 说明：如图所示

多线程的安全与应用_第7张图片

说明：因为cpu全局只有一个不可能对所有的线程进行同时执行，为了让我们看起来在同时执行，在操作系统层面上会有一个时间片的概念，时间片也就是cpu的一段执行时间，时间片送给那个线程，那个县城就有当前计算和执行的权力，其他的线程则处于等待状态，直到时间片被分配给其他线程才会执行。

因为时间片是以纳秒级别来分配，所以在感官上我们会觉得所有线程都是在同时运行的，这种情况我们叫做并发执行。

多线程的安全与应用_第8张图片

说明： 随之技术的发展，现在主流的民用cpu都是i5,i7四核八核十六核，这种多核心的情况下就是真正意义上的并行执行了。

不同的线程之间可以拥有不同的cpu分配的时间片，在物理层面上做到了真正的并行执行。

多线程的安全与应用_第9张图片

在java中进程线程是什么关系呢？

像这种只有一个main方法的代码，我们会将它称为java的“单线程”程序

 当程序启动以后会产生一个如图所示的进程，在这个进程中会包含java中所产生的的线程

多线程的安全与应用_第10张图片

 每一个java程序启动后会至少包含两个线程，除了main在java中我们支持垃圾自动回收，可以自动对垃圾对象进行回收，这个就交给了垃圾收集线程执行，对垃圾进行整理标记和收集。

垃圾收集程序因为是每一个java程序都自带的所以我们并不把他算在其中，通常我们提到的java多线程程序就是指通过咱们自己程序代码所创建出来的线程进行的计算和处理，这被称为多线程，这样的程序被称为多线程程序，只有main方法的主线程程序称为单线程程序。

 2-1 通过继承Thread类创建线程

 说明：本节开始进入实战的环节来了解在java语言环境下，如何创建多线程程序，以及如何实现多个任务同时处理

 说明：分别针对以上三种方式来进行讲解

多线程的安全与应用_第11张图片

 说明：为了方便理解我们模拟一个程序，创建一个主线程和额外的三个线程，让三位参赛者同时向前奔跑，最后得到每位参赛者在10秒内跑了多少距离，要怎么做呢？

 创建演示类

多线程的安全与应用_第12张图片

说明： 通过此案例来演示到底为什么需要多线程程序？以及如果我们直接写main方法他是怎么实现的？单线程和多线程的区别？

package com.imooc.thread;

import java.util.Random;
//继承Thread实现多线程程序
public class ThreadSample1 {
    class Runner extends Thread{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + i + "秒：" + this.getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    public void start(){
        Runner threadA = new Runner();
        threadA.setName("参赛者A");
        Runner threadB = new Runner();
        threadB.setName("参赛者B");
        Runner threadC = new Runner();
        threadC.setName("参赛者C");
        Runner threadD = new Runner();
        threadD.setName("参赛者D");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
    }

    public static void main(String[] args) {
        //System.out.println("参赛者A 10秒跑了100米");
        //System.out.println("参赛者B 10秒跑了60米");
        //System.out.println("参赛者C 10秒跑了80米");
        new ThreadSample1().start();
    }
}

本节代码实例

 多线程的安全与应用_第13张图片

 说明：我们的需求是参赛者同时跑，在main方法中显然是无法做到的，main方法作为主方法，前面的方法执行不完后面的语句就一直处于等待的状态。尽管是主线程带无法做到并行执行的效果。

 thread类来实行多线程程序

 class Runner extends Thread{
        @Override
        //新增内部类Runner重写父类方法run()
        public void run() {
            //书写模拟奔跑的程序，随机生成每秒奔跑的速度
            Integer speed = new Random().nextInt(10);
            //模拟10秒钟奔跑的距离
            for(int i = 1 ; i <= 10 ; i++){
                //getName()就是线程的名字
                System.out.println("第" + i + "秒：" + this.getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    //模拟开始奔跑的方法
    public void start(){
        
        Runner threadA = new Runner();
        threadA.setName("参赛者A");

        //新线程的创建和运行
        threadA.start();

    }
    public static void main(String[] args) {
        new ThreadSample1().start();
    }

运行效果：

 多线程的安全与应用_第14张图片

模拟10秒钟跑的距离

 添加方法让线程沉睡1秒钟

多线程的安全与应用_第15张图片

 因为只有一个自定义线程，所以无法体现出同时跑，设置其他参赛者bcd


    public void start(){
        Runner threadA = new Runner();
        threadA.setName("参赛者A");
        Runner threadB = new Runner();
        threadB.setName("参赛者B");
        Runner threadC = new Runner();
        threadC.setName("参赛者C");
        Runner threadD = new Runner();
        threadD.setName("参赛者D");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
    }

 可以看到每一秒abc都是在同时输出信息

多线程的安全与应用_第16张图片

 每增加一个，就增加一个同时跑的人

 每一秒的执行顺序并不相同，这是因为4个线程都会被操作系统分配时间片来进行执行，谁被先分配了时间片就由先执行的权力，cpu的调度各不相同。

2-2 选择练习 

 多线程的安全与应用_第17张图片

 ​​ 

 

 多线程的安全与应用_第18张图片

 

 2-5 run方法和start方法的区别

 多线程的安全与应用_第19张图片

 多线程的安全与应用_第20张图片

 分别调用start()方法和run()方法进行测试

多线程的安全与应用_第21张图片 

多线程的安全与应用_第22张图片2-6 实现runnable方法接口创建线程

 

 java是只支持单继承的,作为java更推崇的方式是实现接口的方式来进行处理

 新建java类

多线程的安全与应用_第23张图片

package com.imooc.thread;

import java.util.Random;
//实现Runnable接口实现多线程程序
public class ThreadSample2 {
    class Runner implements Runnable{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第" + i + "秒：" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }

    public void start(){
        Runner runner = new Runner();
        Thread threadA = new Thread(runner);
        threadA.setName("参赛者A");
        Thread threadB = new Thread(new Runner());
        threadB.setName("参赛者B");
        Thread threadC = new Thread(new Runner());
        threadC.setName("参赛者C");

        threadA.start();
        threadB.start();
        threadC.start();
    }

    public static void main(String[] args) {
        new ThreadSample2().start();
    }
}

 本节代码示例

    class Runner implements Runnable{
        @Override
        public void run() {
            Integer speed = new Random().nextInt(10);
            for(int i = 1 ; i <= 10 ; i++){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //Thread线程类.currentThread()静态方法，获取到当前执行的线程.getName()得到当前线程名称
                System.out.println("第" + i + "秒：" + Thread.currentThread().getName() + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
        }
    }
public void start(){
        //实例化Runner对象
        Runner runner = new Runner();
        //实例化Thread类
        Thread threadA = new Thread(runner);
        //设置名称
        threadA.setName("参赛者A");
        Thread threadB = new Thread(new Runner());
        threadB.setName("参赛者B");
        Thread threadC = new Thread(new Runner());
        threadC.setName("参赛者C");
        //启动线程，然后去执行里面的run方法
        threadA.start();
        threadB.start();
        threadC.start();
    }
    //测试
    public static void main(String[] args) {
        new ThreadSample2().start();
    }
}

多线程的安全与应用_第24张图片

 传入实现类，当线程运行时就会去Run方法里规定的业务代码

执行效果

多线程的安全与应用_第25张图片 多线程的安全与应用_第26张图片

 谁获取时间片早就相对靠前

作为实现接口的方式在java中是友好的，所以在日常开发中十分常见。推荐此开发方式

 2-7 选择练习

 多线程的安全与应用_第27张图片

多线程的安全与应用_第28张图片

 

2-8 自由编程

多线程的安全与应用_第29张图片

package com.imooc.thread;

public class ThreadExercise {
    class Cat implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 3; i++) {
                System.out.println(Thread.currentThread().getName()+"A Cat");
            }
        }
    }
    class Dog implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 3; i++) {
                System.out.println(Thread.currentThread().getName()+"A Dog");
            }
        }
    }
    public void start(){
        for (int i = 1; i <= 3; i++) {
            System.out.println("main thread");
        }
        //实例化Runner对象
        Dog dog = new Dog();
        Cat cat = new Cat();
        //实例化Thread类
        Thread threadDog = new Thread(dog);
        Thread threadCat = new Thread(cat);
        threadDog.start();
        threadCat.start();
    }

    public static void main(String[] args) {
        ThreadExercise threadExercise = new ThreadExercise();
        threadExercise.start();
        
    }
}

 2-9 实现Callable接口创建线程

 创建类Threadsample3

package com.imooc.thread;

import java.util.Random;
import java.util.concurrent.*;
//实现Callable接口实现多线程程序
public class ThreadSample3 {
    class Runner implements Callable{
        public String name;
        @Override
        public Integer call() throws Exception {
            Integer speed = new Random().nextInt(10);
            Integer result = 0;
            for(int i = 1 ; i <= 10 ; i++){
                Thread.sleep(1000);
                result = i * speed;
                System.out.println("第" + i + "秒：" + this.name + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
            return result;
        }
    }

    public void start() throws ExecutionException, InterruptedException {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Runner threadA = new Runner();
        threadA.name = "参赛者A";
        Runner threadB = new Runner();
        threadB.name = "参赛者B";
        Runner threadC = new Runner();
        threadC.name = "参赛者C";
        //利用Future对象获取每一个线程执行后的结果
        Future r1 = executorService.submit(threadA);
        Future r2 = executorService.submit(threadB);
        Future r3 = executorService.submit(threadC);
        //关闭线程池
        executorService.shutdown();
        System.out.println(threadA.name + "累计跑了" + r1.get() + "米");
        System.out.println(threadB.name + "累计跑了" + r2.get() + "米");
        System.out.println(threadC.name + "累计跑了" + r3.get() + "米");
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new ThreadSample3().start();
    }
}
本节代码示例 

//为什么要定义泛型？原因是利用Callable接口我们实现的应用程序，每一个线程在执行完以后是允许拥有返回值的
    class Runner implements Callable{
        //定义共有成员变量name
        public String name;
        //实现call方法，返回值是Integer
        @Override
        public Integer call() throws Exception {
            //获取随机速度
            Integer speed = new Random().nextInt(10);
            //result是总共要跑的距离，未来要作为执行结果进行返回，默认值为0
            Integer result = 0;
            for(int i = 1 ; i <= 10 ; i++){
                Thread.sleep(1000);
                result = i * speed;
                //name指向的是当前Runner对象的name，而不是线程的名字
                System.out.println("第" + i + "秒：" + this.name + "已跑到" + (i * speed) + "米（" + speed + "米/秒)");
            }
            //返回
            return result;
        }
    }

 如何创建多线程程序？

    public void start() throws ExecutionException, InterruptedException {
        //创建线程池，newFixedThreadPool采用定长线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Runner threadA = new Runner();
        threadA.name = "参赛者A";
        Runner threadB = new Runner();
        threadB.name = "参赛者B";
        Runner threadC = new Runner();
        threadC.name = "参赛者C";
        //利用Future对象获取每一个线程执行后的结果 submit运行很快相当于同时进行
        //运行结果封装成Future对象
        Future r1 = executorService.submit(threadA);
        Future r2 = executorService.submit(threadB);
        Future r3 = executorService.submit(threadC);
        //关闭线程池，shutdown会等到所有执行结束后关闭线程池
        executorService.shutdown();
        //打印结果 get得到运行后的结果 也就是call方法return返回的数据
        System.out.println(threadA.name + "累计跑了" + r1.get() + "米");
        System.out.println(threadB.name + "累计跑了" + r2.get() + "米");
        System.out.println(threadC.name + "累计跑了" + r3.get() + "米");
    }

 调用查看结果

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new ThreadSample3().start();
    }

 多线程的安全与应用_第30张图片

最后会出现 

 这种方法除了可以实现线程原本要做的事情以外，还允许出现返回值

 2-10 线程的生命周期

 什么是生命周期？一个事物由生到死的整个阶段。

 多线程的安全与应用_第31张图片

new 新建状态

runnable 可运行状态

blocked 阻塞状态

waiting 等待状态

timed_waiting 超时等待状态

terminated 结束状态也叫死亡状态

 针对这六种不同的线程状态是如何变化的呢？

多线程的安全与应用_第32张图片

什么是锁？

控制线程是否执行的一个标志，这里可以这么认为，锁本身是一个对象，在多线程情况下某一个线程得到了这个锁，当前线程就可以进入到可运行状态，同时cpu也会分配时间片让线程继续执行。

由于操作系统底层的任务调度还有其他的底层资源发生了变化，我们失去了锁，当前线程就会进入阻塞状态，cpu的时间片就不会分配给当前线程

 在线程执行的过程中如果我们按照大类来区分的话，其实只有两种状态可以获得时间片和不可以获得时间片的可运行和阻塞状态。

业界中通行的五种线程状态

 多线程的安全与应用_第33张图片

并不只针对java，线程这个概念是任何操作系统来进行任务调度的时候都会存在的

这个图是宏观的针对线程的状态

 2-11 选择练习

多线程的安全与应用_第34张图片

 多线程的安全与应用_第35张图片

3-1 初试线程同步并使用Synchronized实现线程同步

 什么是线程同步？

多线程的安全与应用_第36张图片

 多线程的安全与应用_第37张图片

 多个线程对同一个对象进行访问的时候，我们需要加入这个同步机制或同步锁来保证线程的有序执行

 创建SyncSample类演示

package com.imooc.thread;

public class SyncSample {

    class Printer{
        //锁对象
        Object lock = new Object();
        //synchronized代码块演示，对自定义对象lock上锁
        public void print1(){
            synchronized (lock) {
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        //synchronized方法 - 对this当前对象上锁
        public synchronized void print2(){
            try {
                //this
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //synchronized静态方法 - 该类的字节码对象Printer.class
        /*
        public static synchronized void print3(){
            try {
                //Printer.class
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        */
    }

    class PrintTask implements Runnable{
        public Printer printer;
        @Override
        public void run() {
            printer.print2();
        }
    }

    public void start(){
        Printer printer = new Printer();
        for(int i = 0 ; i < 10 ; i++){
            PrintTask task = new PrintTask();
            task.printer = printer;
            Thread thread = new Thread(task);
            thread.start();
        }
    }

    public static void main(String[] args) {
        SyncSample sample = new SyncSample();
        sample.start();
    }
}

首先验证不加同步锁代码会产生什么样的问题？

class Printer{
        public void print(){
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
 public void start(){
        Printer printer = new Printer();
        printer.print();
    }

 public static void main(String[] args) {
        SyncSample sample = new SyncSample();
        sample.start();
    }

 打印后魑魅魍魉四个字依次输出看起来没有问题

 因为我们此时只有一个对象，如果多线程情况下同时调用printer对象就会出现问题


 //增加新的内部类
 class PrintTask implements Runnable{
       //定义一个类的成员变量
        public Printer printer;
        @Override
        public void run() {
            printer.print();
        }
    }

进行实质的多线程输出

    public void start(){
        Printer printer = new Printer();
        for(int i = 0 ; i < 10 ; i++){
            PrintTask task = new PrintTask();
            task.printer = printer;
            Thread thread = new Thread(task);
            thread.start();
        }
    }

十个线程都是引用了同一个printer对象 ，大概在同一个时点内多个线程会同时对魑来进行输出然后依次输出，这与我们的预期相差非常多。为了解决这个问题我们要引入锁的机制让线程一个一个排队执行。

如何做到前面的线程没有执行完的话，后面所有的线程就一直处于阻塞等待的状态？

   class Printer{
        //锁对象，要有一个对象，那个线程抢到了这个锁那个线程就有执行这个代码的权力
        Object lock = new Object();
        //synchronized代码块演示，对自定义对象lock上锁
        public void print1(){
            //指明是那个锁
            synchronized (lock) {
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

重新运行

多线程的安全与应用_第38张图片

 定义锁对象，那个线程优先获取到锁，就优先执行，执行后锁会被释放，由其他线程进行争抢，直到所有的线程最后完成处理

3-2 选择练习 

多线程的安全与应用_第39张图片

 多线程的安全与应用_第40张图片

 

 3-3 Synchronized在不同场景下锁对象的区别

 学习Synchronize3种不同的使用办法，通过这三种不同的使用办法了解他的锁对象有哪些

 多线程的安全与应用_第41张图片

 Synchronize代码块：

//锁对象
        Object lock = new Object();
        //synchronized代码块演示，对自定义对象lock上锁
        public void print1(){
            synchronized (lock) {
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

最典型的特性就是自己自定义一个对象对其进行加锁和保护

新人很容易犯得的错误

我们在实例化的时候对task和thread各自创建了十个对象 ，但我们把十个对象全都关联到一个printer对象里面，为什么呢？

因为在多线程访问时只有对同一个对象来进行访问时才可以获取到同一个锁对象。

多线程的安全与应用_第42张图片

假如我们 注释掉printer在每一次创建新的任务的时候去实例化一个新的printer对象

多线程的安全与应用_第43张图片

 运行后会发现整个代码失去了原有的控制，我们每执行一次循环，都创建了一个全新的printer对象，这也就意味着在代码块执行的过程中每一个printer对象都内置了一个lock

 每一个线程都拥有一个自己的锁对象，因此无法达到我们想要的效果

我们需要的效果是所有线程都去共享一把锁，所以我们全局引用一个printer对象，只有一把锁所有线程去争取这一把锁。

使用synochronized方法

        //synchronized方法 - 对this当前对象上锁
        public synchronized void print2(){
            try {
                //this
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

写在方法上进行描述，同时也不需要我们手动指明那个对象来进行加锁

运行测试

多线程的安全与应用_第44张图片

说明可以进行有效的线程同步
我们并没有指定特定的锁对象，就实现了锁的同步这里的原理是什么？

 开发过程中有一个内置的关键字叫做this对象，this关键字代表了当前类的对象

我们调用多少次的方法作为synochronized对象都是对this对象进行加锁

可以看做是synochronized块的简化书写

静态方法进行描述

//synchronized静态方法 - 该类的字节码对象Printer.class
        /*
        public static synchronized void print3(){
            try {
                //Printer.class
                Thread.sleep(500);
                System.out.print("魑");
                Thread.sleep(500);
                System.out.print("魅");
                Thread.sleep(500);
                System.out.print("魍");
                Thread.sleep(500);
                System.out.print("魉");
                System.out.println();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        */

 静态方法是属于类不属于对象的，因为我们现在使用的是一个内部类

 内部类是不允许使用static的所以写上以后就会报错

static描述的方法是属于类的而不是属于方法的，在这个过程中他的锁对象什么呢？

static无法使用this，按照java的规则会使用当前类的class类printer.class来作为锁对象

对static来说是使用的字节码对象来进行加锁谁得到字节码对象谁有执行权限

 3-4 选择练习

 多线程的安全与应用_第45张图片

 多线程的安全与应用_第46张图片

多线程的安全与应用_第47张图片

 

3-5 实现线程安全解决超卖现象

 什么是线程安全？

多线程的安全与应用_第48张图片

 代码实例

创建mall子包演示

多线程的安全与应用_第49张图片

//消费者类
class Consumer implements Runnable{
    //所有消费者都来到同一个商城
    public Mall mall;
    @Override
    public void run() {
        //商城为每一名消费者销售商品
        mall.sale();
    }
}

//库存类
public class Stock {
    //当前商品库存剩余3个
    public static int count = 3;
}

//模拟商城销售商品
public class Mall {
    public void sale(){
        if(Stock.count > 0 ){
            try {
                //模拟商城办理销售业务，用时5毫秒
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //销售成功库存减少
            Stock.count--;
            System.out.println("商品销售成功");
        }else{
            System.out.println("商品库存不足，请下次再来吧！");
        }
    }

    public static void main(String[] args) {
        //实例化唯一的商城对象
        Mall mall = new Mall();
        //模拟5名顾客同时涌入商城购买商品
        for(int i = 0 ; i < 100 ; i++){
            Consumer consumer = new Consumer();
            consumer.mall = mall;
            Thread thread = new Thread(consumer);
            thread.start();
        }
        try {
            //模拟下班后判断库存
            Thread.sleep(1000);
            System.out.println("当前商品库存为：" + Stock.count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

只有一名顾客时处理的逻辑

 5名时就变成了

这时就会产生超卖现象 倒赔2台手机

这就是典型的线程安全问题

在单线程处理的时候运行逻辑是正常的，但是一旦到多线程运行的时候就会出现没有预估到的效果，就是线程安全问题

 多线程的安全与应用_第50张图片

 如何解决？

所有的线程安全问题都是多个线程访问一个对象，而我们没有对着一个对象进行有效规划造成的，引入之前学的线程同步解决这个问题 增加synchronized关键字

public class Mall {
    public synchronized void sale(){
        if(Stock.count > 0 ){
            try {
                //模拟商城办理销售业务，用时5毫秒
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //销售成功库存减少
            Stock.count--;
            System.out.println("商品销售成功");
        }else{
            System.out.println("商品库存不足，请下次再来吧！");
        }
    }

运行

多线程的安全与应用_第51张图片

 如何快速打开java自带类的源码？

ctrl+n键

输入类名 

打开ArrayList

多线程的安全与应用_第52张图片

并没有synchronized 关键字进行描述

但是在Vector却使用了synchronized 关键字进行描述

多线程的安全与应用_第53张图片

 加和不加就意味着当前方法是不是线程安全的，加上就是没加就不是

为什么开发时都在使用ArrayList而不再使用早期的Vector呢？

原因是通过ArrayList可以有效通过我们执行的速度，平时工作过程中多线程还是少见的，我们要快速的完成对数据的处理和操作。所以会优先选择线程不安全的方法

4-1 初识线程池及其基本应用

 首先来了解一个包

多线程的安全与应用_第54张图片

 在并发包中最核心的组件就是线程池了

多线程的安全与应用_第55张图片

多线程的安全与应用_第56张图片

 多线程的安全与应用_第57张图片

 4-2 线程池的四种类型

 通过代码介绍四种线程池的不同类型和特点

创建pool包

多线程的安全与应用_第58张图片

 新建第一个案例ThreadPoolSample1 定长线程池

public class ThreadPoolSample1 {
    public static void main(String[] args) {
        //创建一个可创建一个定长线程池，最大只允许在线程池中有10个线程同时运行
        //定长线程池的特点是固定线程总数，空闲线程用于执行任务，如果线程都在使用，后续任务则处于等待状态
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        //验证一下下线程池做法 
        for(int i = 1; i <= 1000 ; i++){
            final int index = i;
            //不需要返回值，使用execute方法执行Runnable对象
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    //获取当前线程名字
                    System.out.println(Thread.currentThread().getName()+":" + index );
                }
            });
        }
        //处理完毕关闭线程池
        threadPool.shutdown();
    }
}

运行看是否最多10个线程执行任务

多线程的安全与应用_第59张图片

 可以看到只有10个线程的名字，通过10个固定长度的线程处理了1000个任务

 如果需要返回值呢？

            /*
            需要返回值，使用submit方法执行Callable对象，利用Future对象接收返回值
            Future ret = threadPool.submit(new Callable() {
                @Override
                public Object call() throws Exception {
                    return null;
                }
            });
            */

增加其他三种类型代码案例




public class ThreadPoolSample2 {
    public static void main(String[] args) {
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();//创建一个可缓存线程池
        //可缓存线程池的特点是，无限大，如果线程池中没有可用的线程则创建，有空闲线程则利用起来
        for(int i = 1 ; i <= 1000 ; i++) {
            final  int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        threadPool.shutdown();
    }
}


多线程的安全与应用_第60张图片 




作为可缓存线程池主要代码和定长线程池几乎一样，唯一不同的是Executors.newCachedThreadPool();//创建一个可缓存线程池，同时并没有传入任何线程的总量




public class ThreadPoolSample3 {
    public static void main(String[] args) {
        //调度器对象
        //ExecutorService用于管理线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单线程线程池
        for(int i = 1 ; i <= 1000 ; i++) {
            final  int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + index);
                }
            });
        }
        threadPool.shutdown();
    }
}



多线程的安全与应用_第61张图片 




单线程代表所有的任务都通过一个任务排队来执行


Executors.newSingleThreadExecutor();//单线程线程池




public class ThreadPoolSample4 {
    public static void main(String[] args) {
        //调度线程池
        ScheduledExecutorService scheduledThreadPool =  Executors.newScheduledThreadPool(5);//可调度线程池
        //延迟1秒执行，每三秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(new Date() + "延迟1秒执行，每三秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }
}


 




调度线程池就是定时执行某个任务


Executors.newScheduledThreadPool(5);//可调度线程池
 所有任务都是以定时的时长间隔来执行run方法中所规定的东西




4-3 课程总结 




 多线程的安全与应用_第62张图片

























你可能感兴趣的:(多线程,java)






    

  • 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()，那么我们在接口
    

    • 

  • 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分别代
    

    • 

  • 关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
    

    • 

  • 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的运行
    

    • 

  • Java 重写(Override)与重载(Overload)
叨唧唧的

    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    

    • 

  • 简单了解 JVM
记得开心一点啊
jvm

    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    

    • 

  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
Energet!c
开发语言

    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    

    • 

  • Java企业面试题3
马龙强_
java

    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    

    • 

  • JVM、JRE和 JDK：理解Java开发的三大核心组件
Y雨何时停T
Javajava

    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    

    • 

  • 多线程之——ExecutorCompletionService
阿福德

    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
    

    • 

  • Java面试题精选：消息队列(二)
芒果不是芒
Java面试题精选javakafka

    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    

    • 

  • python多线程程序设计 之一
IT_Beijing_BIT
#Python程序设计语言python

    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
    

    • 

  • 白骑士的Java教学基础篇 2.5 控制流语句
白骑士所长
Java教学java开发语言

    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    

    • 

  • python语法——三目运算符
HappyRocking
pythonpython三目运算符

    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    

    • 

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • Java爬虫框架（一）--架构设计
狼图腾-狼之传说
java框架java任务html解析器存储电子商务

    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    

    • 

  • Java：爬虫框架
dingcho
Javajava爬虫

    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    

    • 

  • python怎么将png转为tif_png转tif
weixin_39977276

    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    

    • 

  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
跳房子的前端
前端面试javascript开发语言ecmascript

    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    

    • 

  • Python多线程实现大规模数据集高效转移
sand&wich
网络python服务器

    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
    

    • 

  • JAVA·一个简单的登录窗口
MortalTom
java开发语言学习

    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    

    • 

  • Python实现下载当前年份的谷歌影像
sand&wich
python开发语言

    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
    

    • 

  • WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言

    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    

    • 

  • 博客网站制作教程
2401_85194651
javamaven

    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    

    • 

  • 00. 这里整理了最全的爬虫框架（Java + Python）
有一只柴犬
爬虫系列爬虫javapython

    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    

    • 

  • JAVA学习笔记之23种设计模式学习
victorfreedom
Java技术设计模式androidjava常用设计模式

    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    

    • 

  • VMware Workstation 11 或者 VMware Player 7安装MAC OS X 10.10 Yosemite
iwindyforest
vmwaremac os10.10workstationplayer

    最近尝试了下VMware下安装MacOS 系统，
安装过程中发现网上可供参考的文章都是VMware Workstation 10以下， MacOS X 10.9以下的文章，
只能提供大概的思路， 但是实际安装起来由于版本问题， 走了不少弯路， 所以我尝试写以下总结， 希望能给有兴趣安装OSX的人提供一点帮助。
 
 
写在前面的话：
其实安装好后发现， 由于我的th
    

    • 

  • 关于《基于模型驱动的B/S在线开发平台》源代码开源的疑虑？
deathwknight
JavaScriptjava框架

    本人从学习Java开发到现在已有10年整，从一个要自学 java买成javascript的小菜鸟，成长为只会java和javascript语言的老菜鸟（个人邮箱：[email protected]）
一路走来，跌跌撞撞。用自己的三年多业余时间，瞎搞一个小东西（基于模型驱动的B/S在线开发平台，非MVC框架、非代码生成）。希望与大家一起分享，同时有许些疑虑，希望有人可以交流下
平台
    

    • 

  • 如何把maven项目转成web项目
Kai_Ge
mavenMyEclipse

    创建Web工程，使用eclipse ee创建maven web工程 1.右键项目,选择Project Facets,点击Convert to faceted from 2.更改Dynamic Web Module的Version为2.5.(3.0为Java7的,Tomcat6不支持). 如果提示错误,可能需要在Java Compiler设置Compiler compl
    

    • 

  • 主管？？？
Array_06
工作

    转载：http://www.blogjava.net/fastzch/archive/2010/11/25/339054.html
很久以前跟同事参加的培训，同事整理得很详细，必须得转！
前段时间，公司有组织中高阶主管及其培养干部进行了为期三天的管理训练培训。三天的课程下来，虽然内容较多，因对老师三天来的课程内容深有感触，故借着整理学习心得的机会，将三天来的培训课程做了一个
    

    • 

  • python内置函数大全
2002wmj
python

    最近一直在看python的document，打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面，其实在看的时候发现整个《The Python Standard Library》章节都是很不错的，其中描述了很多不错的主题。先把Build-in Fu
    

    • 

  • JSP页面通过JQUERY合并行
357029540
JavaScriptjquery

    在写程序的过程中我们难免会遇到在页面上合并单元行的情况，如图所示
如果对于会的同学可能很简单，但是对没有思路的同学来说还是比较麻烦的，提供一下用JQUERY实现的参考代码
function mergeCell(){
        var trs = $("#table tr");
&nb
    

    • 

  • Java基础
冰天百华
java基础

    学习函数式编程
package base;
import java.text.DecimalFormat;
public class Main {
public static void main(String[] args) {
// Integer a = 4;
// Double aa = (double)a / 100000;
// Decimal
    

    • 

  • unix时间戳相互转换
adminjun
转换unix时间戳

    如何在不同编程语言中获取现在的Unix时间戳(Unix timestamp)？ Java time JavaScript Math.round(new Date().getTime()/1000)
getTime()返回数值的单位是毫秒 Microsoft .NET / C# epoch = (DateTime.Now.ToUniversalTime().Ticks - 62135
    

    • 

  • 作为一个合格程序员该做的事
aijuans
程序员

    作为一个合格程序员每天该做的事 1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多
2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作
3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重
    

    • 

  • 由html5视频播放引发的总结
ayaoxinchao
html5视频video

    前言
 
项目中存在视频播放的功能，前期设计是以flash播放器播放视频的。但是现在由于需要兼容苹果的设备，必须采用html5的方式来播放视频。我就出于兴趣对html5播放视频做了简单的了解，不了解不知道，水真是很深。本文所记录的知识一些浅尝辄止的知识，说起来很惭愧。
 
视频结构
 
本该直接介绍html5的<video>的，但鉴于本人对视频
    

    • 

  • 解决httpclient访问自签名https报javax.net.ssl.SSLHandshakeException: sun.security.validat
bewithme
httpclient

         如果你构建了一个https协议的站点，而此站点的安全证书并不是合法的第三方证书颁发机构所签发，那么你用httpclient去访问此站点会报如下错误
 
javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path bu
    

    • 

  • Jedis连接池的入门级使用
bijian1013
redisredis数据库jedis

    Jedis连接池操作步骤如下：
        a.获取Jedis实例需要从JedisPool中获取；
        b.用完Jedis实例需要返还给JedisPool；
        c.如果Jedis在使用过程中出错，则也需要还给JedisPool；
packag
    

    • 

  • 变与不变
bingyingao
不变变亲情永恒

    变与不变
   周末骑车转到了五年前租住的小区，曾经最爱吃的西北面馆、江西水饺、手工拉面早已不在，
   各种店铺都换了好几茬，这些是变的。
   三年前还很流行的一款手机在今天看起来已经落后的不像样子。
   三年前还运行的好好的一家公司，今天也已经不复存在。
   一座座高楼拔地而起，
    

    • 

  • 【Scala十】Scala核心四：集合框架之List
bit1129
scala

    Spark的RDD作为一个分布式不可变的数据集合，它提供的转换操作，很多是借鉴于Scala的集合框架提供的一些函数，因此，有必要对Scala的集合进行详细的了解
 
1. 泛型集合都是协变的，对于List而言，如果B是A的子类，那么List[B]也是List[A]的子类，即可以把List[B]的实例赋值给List[A]变量
 
2. 给变量赋值(注意val关键字，a，b
    

    • 

  • Nested Functions in C
bookjovi
cclosure

     
Nested Functions 又称closure，属于functional language中的概念，一直以为C中是不支持closure的，现在看来我错了，不过C标准中是不支持的，而GCC支持。
 
既然GCC支持了closure，那么 lexical scoping自然也支持了，同时在C中label也是可以在nested functions中自由跳转的
    

    • 

  • Java-Collections Framework学习与总结-WeakHashMap
BrokenDreams
Collections

            总结这个类之前，首先看一下Java引用的相关知识。Java的引用分为四种：强引用、软引用、弱引用和虚引用。
       
强引用：就是常见的代码中的引用，如Object o = new Object();存在强引用的对象不会被垃圾收集
    

    • 

  • 读《研磨设计模式》-代码笔记-解释器模式-Interpret
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
package design.pattern;
/*
* 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象
*
* 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值
* 多
    

    • 

  • After Effects操作&快捷键
cherishLC
After Effects

    1、快捷键官方文档
中文版：https://helpx.adobe.com/cn/after-effects/using/keyboard-shortcuts-reference.html
英文版：https://helpx.adobe.com/after-effects/using/keyboard-shortcuts-reference.html
2、常用快捷键
    

    • 

  • Maven 常用命令
crabdave
maven

    Maven 常用命令
 
mvn archetype:generate
mvn install
mvn clean
mvn clean complie
mvn clean test
mvn clean install
mvn clean package
mvn test
mvn package
mvn site
 
mvn dependency:res
    

    • 

  • shell bad substitution
daizj
shell脚本

    #!/bin/sh
/data/script/common/run_cmd.exp 192.168.13.168 "impala-shell -islave4 -q 'insert OVERWRITE table imeis.${tableName} select ${selectFields}, ds, fnv_hash(concat(cast(ds as string), im
    

    • 

  • Java SE 第二讲（原生数据类型 Primitive Data Type）
dcj3sjt126com
java

    Java SE  第二讲：
1.   Windows: notepad, editplus, ultraedit, gvim
Linux: vi, vim, gedit
2.   Java 中的数据类型分为两大类：
1）原生数据类型  （Primitive Data Type）
2）引用类型（对象类型）  （R
    

    • 

  • CGridView中实现批量删除
dcj3sjt126com
PHPyii

    1，CGridView中的columns添加
array(
'selectableRows' => 2,
'footer' => '<button type="button" onclick="GetCheckbox();" style=&
    

    • 

  • Java中泛型的各种使用
dyy_gusi
java泛型

    Java中的泛型的使用：1.普通的泛型使用
在使用类的时候后面的<>中的类型就是我们确定的类型。
public class MyClass1<T> {//此处定义的泛型是T
private T var;
public T getVar() {
return var;
}
public void setVa
    

    • 

  • Web开发技术十年发展历程
gcq511120594
Web浏览器数据挖掘

    回顾web开发技术这十年发展历程：
Ajax
03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。
彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
    

    • 

  • openSession()与getCurrentSession()区别：
hetongfei
javaDAOHibernate

    来自 http://blog.csdn.net/dy511/article/details/6166134
1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。
2. getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭。
这里getCurrentSession本地事务(本地
    

    • 

  • 第一章 安装Nginx+Lua开发环境
jinnianshilongnian
nginxluaopenresty

    首先我们选择使用OpenResty，其是由Nginx核心加很多第三方模块组成，其最大的亮点是默认集成了Lua开发环境，使得Nginx可以作为一个Web Server使用。借助于Nginx的事件驱动模型和非阻塞IO，可以实现高性能的Web应用程序。而且OpenResty提供了大量组件如Mysql、Redis、Memcached等等，使在Nginx上开发Web应用更方便更简单。目前在京东如实时价格、秒
    

    • 

  • HSQLDB In-Process方式访问内存数据库
liyonghui160com

     
 
HSQLDB一大特色就是能够在内存中建立数据库，当然它也能将这些内存数据库保存到文件中以便实现真正的持久化。
 
先睹为快！
 
下面是一个In-Process方式访问内存数据库的代码示例：
 
 
下面代码需要引入hsqldb.jar包 （hsqldb-2.2.8）
 
import java.s
    

    • 

  • Java线程的5个使用技巧
pda158
java数据结构

    Java线程有哪些不太为人所知的技巧与用法？ 　　萝卜白菜各有所爱。像我就喜欢Java。学无止境，这也是我喜欢它的一个原因。日常
工作中你所用到的工具，通常都有些你从来没有了解过的东西，比方说某个方法或者是一些有趣的用法。比如说线程。没错，就是线程。或者确切说是Thread这个类。当我们在构建高可扩展性系统的时候，通常会面临各种各样的并发编程的问题，不过我们现在所要讲的可能会略有不同。 
    

    • 

  • 开发资源大整合：编程语言篇——JavaScript（1）
shoothao
JavaScript

    概述：本系列的资源整合来自于github中各个领域的大牛，来收藏你感兴趣的东西吧。  
  程序包管理器
  管理javascript库并提供对这些库的快速使用与打包的服务。
Bower - 用于web的程序包管理。
component - 用于客户端的程序包管理，构建更好的web应用程序。
spm - 全新的静态的文件包管
    

    • 

  • 避免使用终结函数
vahoa.ma
javajvmC++

    终结函数（finalizer）通常是不可预测的，常常也是很危险的，一般情况下不是必要的。使用终结函数会导致不稳定的行为、更差的性能，以及带来移植性问题。不要把终结函数当做C++中的析构函数（destructors）的对应物。
 
    我自己总结了一下这一条的综合性结论是这样的：
1）在涉及使用资源，使用完毕后要释放资源的情形下，首先要用一个显示的方
    

    •