多线程，线程池

#博学谷IT学习技术支持#

个人笔记后续会进行内容改进

进程、线程：

多线程实现方法：

线程操作方法：

线程池：

乐观锁&悲观锁

进程和线程的理解：

进程：正在运行的程序

线程：程序内的一个功能或多个功能

实现多线程的方法a：一继承二实现

1. 继承Thread类
   1. Thread中的两个方法：start（）、run（）
   2. 两个方法的区别，start是开启线程，让虚拟机jvm调用run方法

Run是封装执行的代码，相当于普通方法，不开启线程

1. 实现Rannable接口，重写run方法

• 1. 实现步骤
  2. 定义一个类MyRunnable实现Runnable接口
  3. 在MyRunnable类中重写run()方法
  4. 创建MyRunnable类的对象
  5. 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  6. 启动线程
     • 代码：

public class MyRunnable implements Runnable {

    @Override

    public void run() {

        for(int i=0; i<100; i++) {

            System.out.println(Thread.currentThread().getName()+":"+i);

        }

    }

}

public class MyRunnableDemo {

    public static void main(String[] args) {

        //创建MyRunnable类的对象

        MyRunnable my = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数

        //Thread(Runnable target)

//        Thread t1 = new Thread(my);

//        Thread t2 = new Thread(my);

        //Thread(Runnable target, String name)

        Thread t1 = new Thread(my,"坦克");

        Thread t2 = new Thread(my,"飞机");

        //启动线程

        t1.start();

        t2.start();

    }

}

1. 实现callable接口，重写call方法，有返回值
   1. 实现步骤
   2. 定义一个类MyCallable实现Callable接口
   3. 在MyCallable类中重写call()方法
   4. 创建MyCallable类的对象
   5. 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
   6. 创建Thread类的对象，把FutureTask对象作为构造方法的参数
   7. 启动线程
   8. 再调用get方法，就可以获取线程结束之后的结果。
      • 代码：

public class MyCallable implements Callable<String> {

    @Override

    public String call() throws Exception {

        for (int i = 0; i < 100; i++) {

            System.out.println("跟女孩表白" + i);

        }

        //返回值就表示线程运行完毕之后的结果

        return "答应";

    }

}

public class Demo {

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

        //线程开启之后需要执行里面的call方法

        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象

        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象

        Thread t1 = new Thread(ft);

        String s = ft.get();

        //开启线程

        t1.start();

        //String s = ft.get();

        System.out.println(s);

    }

}

三种实现方式的对比

+ 实现Runnable、Callable接口

  + 好处: 扩展性强，实现该接口的同时还可以继承其他的类

  + 缺点: 编程相对复杂，不能直接使用Thread类中的方法

+ 继承Thread类

  + 好处: 编程比较简单，可以直接使用Thread类中的方法

  + 缺点: 可以扩展性较差，不能再继承其他的类

对线程的操作：

| 方法名                     | 说明                               |

| void  setName(String name) | 将此线程的名称更改为等于参数name   |

| String  getName()          | 返回此线程的名称                   |

| Thread  currentThread()    | 返回对当前正在执行的线程对象的引用 |

| void wait()      | 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 |

| void notify()    | 唤醒正在等待对象监视器的单个线程                             |

| void notifyAll() | 唤醒正在等待对象监视器的所有线程                             |

| static void sleep(long millis) | 使当前正在执行的线程停留（暂停执行）指定的毫秒数 |

| final int getPriority()                 | 返回此线程的优先级                                           |

| final void setPriority(int newPriority) | 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |

void setDaemon(boolean on)将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

线程同步：

多线程产生线程安全。Java提供同步代码的方式解决：

synchronized(任意对象) {

多条语句操作共享数据的代码

}

相当于给线程上了锁，每次值有一个线程可以执行代码块的内容

好处：解决了多线程的数据安全问题

弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

Else：

把synchronized关键字加到方法上，锁对象就是this

把synchronized关键字加到静态方法上，锁对象就是leiming.class

线程池：

线程的状态可以分为六大类：

新建状态：new

可运行的：runnable

终结状态：线程执行完毕

等待；wait。线程获取到锁，但是条件不满足进入等待状态，等待其他吃锁线程执行notify|noyifyall方法进行唤醒进入运行状态

阻塞：没有抢到锁的线程

有时限等待：被sleep的线程，时间一过也会进入runable

后面的三类不会占用cpu内存

默认线程池创建：（自动）

1. ExecutorService executorService = Executors.newCachedThreadPool();

//Executors --- 可以帮助我们创建线程池对象

        //ExecutorService --- 可以帮助我们控制线程池

/括号内可以加入参数，代表最大线程数量

1. Submit执行线程
2. executorService.shutdown();结束线程

手动创建：

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,任务队列,创建线程工厂,任务的拒绝策略);

public ThreadPoolExecutor(int corePoolSize, 正式员工

                              int maximumPoolSize,  正式员工+临时员工

                              long keepAliveTime, 临时员工空闲时间

                              TimeUnit unit, 空闲单位

                              BlockingQueue<Runnable> workQueue,  等待队列

                              ThreadFactory threadFactory, 线程工厂，默认

                              RejectedExecutionHandler handler) 拒绝策略

    

corePoolSize：   核心线程的最大值，不能小于0

maximumPoolSize：最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize

keepAliveTime：  空闲线程最大存活时间,不能小于0

unit：           时间单位

workQueue：      任务队列，不能为null

threadFactory：  创建线程工厂,不能为null      

handler：        任务的拒绝策略,不能为null  

流程是：来请求主线程先调用，主线程用完，放入等待队列，等待队列满了，调用临时线程，都满了就调用拒绝策略

拒绝策略：

ThreadPoolExecutor.AbortPolicy:     丢弃任务并抛出RejectedExecutionException异常。是默认的策略。

ThreadPoolExecutor.DiscardPolicy：    丢弃任务，但是不抛出异常 这是不推荐的做法。

ThreadPoolExecutor.DiscardOldestPolicy：    抛弃队列中等待最久的任务 然后把当前任务加入队列中。

ThreadPoolExecutor.CallerRunsPolicy:        调用任务的run()方法绕过线程池直接执行。

乐观锁&悲观锁

悲观锁的代表是 synchronized 和 Lock 锁

其核心思想是【线程只有占有了锁，才能去操作共享变量，每次只有一个线程占锁 成功，获取锁失败的线程，都得停下来等待】

线程从运行到阻塞、再从阻塞到唤醒，涉及线程上下文切换，如果频繁发生，影响 性能

实际上，线程在获取 synchronized 和 Lock 锁时，如果锁已被占用，都会做几次 重试操作，减少阻塞的机会

乐观锁的代表是 AtomicInteger，使用 cas 来保证原子性

其核心思想是【无需加锁，每次只有一个线程能成功修改共享变量，其它失败的线 程不需要停止，不断重试直至成功】

由于线程一直运行，不需要阻塞，因此不涉及线程上下文切换

它需要多核 cpu 支持，且线程数不应超过 cpu 核数