线程类、线程池

线程类 Thread

两个构造方法 空参和有参

空参Thread()：分配一个新的thread对象，不可指定名字

有参 Thread(String name)：创建一个新线程，可起名

常用方法：

start（）：开启线程

run（）：执行 描述任务

sleep（long millis）：设置毫秒值 让正在执行的线程休眠

创建线程步骤

1.先继承thread类  2.重写run 3.创建子类对象（线程对象）4.调用start方法，开启线程让线程执行，让jvm调用run方法

线程对象调run和调start区别

线程调用run不开启线程。调Start 开启线程，让jvm调用run在开启线程中执行

why？继承Thread类原理

Thread类是个默认类，用来描述，我们定义的这个线程做Thread的子类，是为了利用其Thread本有的功能，子继承父，并拥有它的功能

创建线程目的：

目的有单独路径，让多部分代码同时执行

原理图

看似两个方法同时在运行，其实是CPU快速的切换所以两边都在执行

package com.oracle.demo01;
新建子类
public class MyThread extends Thread{
//    重写run方法
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("myThread-"+i);
        }
        super.run();
    }
}

package com.oracle.demo01;
测试
public class Demo01 {
    public static void main(String[] args) {        
//        创建新线程(创建子类对象)
        MyThread thread=new MyThread();
//        开启线程 调start（）
        thread.start();
        for(int i=0;i<20;i++){
            System.out.println("main-"+i);
        }
    }
}

创建线程方式（继承Thread类）

获取线程名称 

currentThread()：用谁调用就会返回调用当前方法线程的对象

getName()：以前获取方法名是用报错的方法获取名称，现在可以直接用getName来代表

在新线程里获得名称，直接用getName就可以，因为里面没有静态

在main里想获得主线程，先获得主线程的对象，在获得主线程名称

package com.oracle.demo01;
//定义一个类继承Thread
public class MyThread extends Thread{
//    重写run方法
    public void run() {
//        getName()获取当前线程名称
        System.out.println("线程名称为"+getName());
        for(int i=0;i<20;i++){
            System.out.println("myThread-"+i);
        }
        super.run();
    }
}

package com.oracle.demo01;
//用.currentThread()获取名称
public class Demo01 {
    public static void main(String[] args) {    
//        获取执行当前代码线程的线程对象
        Thread th=Thread.currentThread();
//        获取该线程的名称
        System.out.println(th.getName());
//        创建新线程(创建子类对象)
        MyThread thread=new MyThread();
//        开启线程 调start（）
        thread.start();
        for(int i=0;i<20;i++){
            System.out.println("main-"+i);
        }
    }
}

创建线程方式-实现Runnable接口（推荐）

接口中的方法 run()：

Thread类构造方法

步骤：

1.定义类实现Runnable接口

2. 覆盖接口的run方法

3.创建Thread类对象

4 .强Runnable接口子类对象作为参数传递给Thread类的构造函数

5.调用Thread类的start（）开启线程

package com.oracle.demo01;
//定义一个类 实现Runnable
//让它实现Runnable 让MyRunnable作为新线程任务
public class MyRunnable implements Runnable{
    
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("Thread-0"+i);
        }
    }
} 

package com.oracle.demo01;
//测试Runnable类接口
public class Demo02 {
    public static void main(String[] args) {
//        创建线程任务对象 :MyRunnable：描述任务
        MyRunnable mr=new MyRunnable();
//        创建Thread类对象：开启线程
        Thread th=new Thread(mr);
//        开启线程
        th.start();
        for(int i=0;i<20;i++){
            System.out.println("main-"+i);
        }
    }
}

实现Runnable原理（为什么用Runnable）

Runnable是Thread的接口，“推荐用接口的方式”生成线程，因为接口可以实现多继承 避免单一继承局限性，如果用Thread类，只能继承和创建Thread，如果用Runnable可以实现后可再继承，比Thread多了个备用功能 覆盖Runnable接口的run方法，将线程任务定义到run方法中。将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象思想将任务封装成对象

 线程匿名内部类

 匿名内部类最后得到的是子类或实现对象

package com.oracle.demo01;
//两个匿名内部类方式
public class Neibulei {
    public static void main(String[] args) {
        /*new 父类或接口名(){
            需要重写方法
        }*/
//        1.创建线程方式 继承Thread类
        new Thread(){            
//            重写run(): 写出run然后alt+/
            public void run() { 
                System.out.println(getName()+"这是新线程任务");
            }
//            匿名内部类方式：创建和开启线程一步到位
        }.start();
//        2.实现Runnable接口
        Runnable run=new Runnable(){
            public void run() {
//                获取当前执行线程对象
                String name=Thread.currentThread().getName();
                System.out.println(name+"这是匿名内部类第二个方式");
            }    
//        最后得到的是线程任务对象
        };
        new Thread(run).start();
    }
}

pm

线程池

概念：一个容纳多个线程的容器，可以反复使用，省去创先线程的操作，不用反复创建，消耗资源

线程状态

线程池原理：

Runnable接口：无返回值，不可抛异常、throws 都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法

package com.oracle.demo02;

//实现Runnable
public class MyRun implements Runnable{
//    重写里面的run方法
    @Override
    public void run() {
//        获取执行当前线程对象的名字
        String name=Thread.currentThread().getName();
        for(int i=0;i<20;i++){
            System.out.println(name+i);//描述线程任务，让线程做什么任务
//            让这个线程每次执行完都休息一下设置休息毫秒值
//            这里为什么用try catch ：这里的run()是Runnable接口的方法，如果父类方法没抛异常，子继承父，实现重写方法，不能抛，只能try catch
            try {
//                打印一次线程 休眠5秒 
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }        
    }    
}

package com.oracle.demo02;

public class Demo01 {
    public static void main(String[] args) {
//        创建线程任务对象
        MyRun mr=new MyRun();
//        创建线程对象
        Thread th=new Thread(mr);
//        开启线程
        th.start();
    }
}

package com.oracle.demo02;
//用接口Runnable的方式实现线程任务
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo02 {
    public static void main(String[] args) {
//        用线程池的方式完成线程工厂任务
//        1.从线程池工厂中获取装有两条线程池的线程池对象
        ExecutorService es=Executors.newFixedThreadPool(2);
//        2.创建线程任务对象
        MyRun mr=new MyRun();
//        让线程池自主选一条线程执行线程任务
        es.submit(mr);
        es.submit(mr);
        es.submit(mr);//这里有三个线程任务 但只能完成两条任务 第二个会等第一个的有空了就执行
//        关闭线程池(一般不关)
        es.shutdown();//关就调用shutdown 关闭后就无法在取线程了
    }
}

 Callable接口：用来指定线程任务，call方法 有返回值， 可以throws，有泛型 与返回值类型相同，

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String>{
    public String call() throws Exception {
        return "abc";
    }

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo01 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
//      1.从线程池工厂中获取线程池对象
        ExecutorService es=Executors.newFixedThreadPool(2);
//      2.创建线程任务对象
        MyCallable mc=new MyCallable();
//      3.让线程池自主选择一条线程执行线程任务
        Future<String>    f=es.submit(mc);
//      4.获取线程任务的返回值
        System.out.println(f.get());
    }
}

 Future接口：记录线程任务执行完毕后产生的结果  线程池创建与使用

 get() 获取Future对象中封装的数据结果

import java.util.concurrent.Callable;

public class MyCall implements Callable<Integer>{
    private int num;
    private int num1;
    public MyCall(){}
    public MyCall(int num,int num1){
        this.num=num;
        this.num1=num1;
    }
    public Integer call() throws Exception {
//       计算求和
        int sum=0;
        for(int i=num;i<=num1;i++){
            sum+=i;
        }
        return sum;
    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo01 {
    //用线程池计算50到100的和------44.....200的和
    public static void main(String[] args) throws InterruptedException, ExecutionException {
//      1.从线程池工厂获取线程池对象
        ExecutorService es=Executors.newFixedThreadPool(2);
//      2.创建线程任务对象
        MyCall mc1=new MyCall(50,100);
        MyCall mc2=new MyCall(44,200);
//      3.让线程池自主选择线程执行任务
        Future<Integer> f1=es.submit(mc1);
        Future<Integer>    f2=es.submit(mc2);
//      4.获取线程任务返回值
        int sum1=f1.get();
        int sum2=f2.get();
        System.out.println(sum1);
        System.out.println(sum2);
    }
}

多线程

线程安全：多线程和单线程每次运行结果相同，其他变量值也和预期一样，就是线程安全

线程同步：Synchronized

①、同步代码块：

　　synchronized (锁对象) {

    　　　　可能会产生线程安全问题的代码

}

public class Tickets implements Runnable {
    // 创建售票类
    // 定义100张票
    private int tickect = 100;
    // 定义同步锁--必须定义在外面 表示所有的线程都使用同一个锁！
    Object obj = new Object();
    public void run() {
        while (true) {
            /*同步代码块将可能会产生线程安全问题的代码包起来---
            各个线程经过时都需要带着锁obj而进行下一步，如果没有的话需要在此等待。
            同时这个线程结束的时候将锁归还，这样下一个线程就可以拿着这个锁进行下一步操作！
            obj可以写成本类对象的this，因为其唯一性，不需要上面的定义！*/
            synchronized (obj) {
                if (tickect > 0) {
                    try {
                        //假设休眠50--这里是制造线程不安全的情况！只是举例的一种！！
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // 先赋值后--
                    System.out.println(Thread.currentThread().getName() + ":出售第" + tickect-- + "张票");
                }
            }
        }
    }
}

public class Demo01 {
    public static void main(String[] args) {
        //1.创建线程任务
        Tickets tickets=new Tickets();
        //创建三个线程完成同一个任务
        Thread t1=new Thread(tickets);
        Thread t2=new Thread(tickets);
        Thread t3=new Thread(tickets);
        //开启线程
        t1.start();
        t2.start();
        t3.start();
    }
}

同步代码方法：

public synchronized void method(){

   　　　　可能会产生线程安全问题的代码

　　}

public class Tickets2 implements Runnable {
    // 创建售票类
    // 定义100张票
    private int tickect = 100;
    // 定义同步锁--必须定义在外面 表示所有的线程都使用同一个锁！
    Object obj = new Object();
    public void run() {
        while (true) {
            method();
        }
    }
    public synchronized void method() {
        if (tickect > 0) {
            try {
                // 假设休眠50--这里是制造线程不安全的情况！只是举例的一种！！
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 先赋值后--
            System.out.println(Thread.currentThread().getName() + ":出售第" + tickect-- + "张票");
        }
    }
}

静态同步方法: 在方法声明上加 static synchronized

public static synchronized void method(){

　　　　可能会产生线程安全问题的代码

　　}

静态同步方法中的锁对象是 类名.class（字节码（.class）文件的对象<字节码文件一进内存就自动生成字节码文件对象>唯一性）

lock接口：

lock 获取锁   unlock 释放锁

package com.oracle.demo01;
//接口锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Tickets3 implements Runnable {
    // 定义100张票
    private int tickect = 100;
    //创建锁接口对象---用于解决可能出现因为异常而导致锁不被还回来
    Lock lock=new ReentrantLock();
    public void run() {
        while (true) {
            //获取锁
            lock.lock();
            if (tickect > 0) {
                try {
                    // 假设休眠50--这里是制造线程不安全的情况！只是举例的一种！！
                    Thread.sleep(50);
                    System.out.println(Thread.currentThread().getName() + ":出售第" + tickect-- + "张票");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }finally{
                    //释放锁
                    lock.unlock();        
                }
                // 先赋值后--                
            }
        }
    }
}