一、进程与线程

进程与线程

1、进程

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间）。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

进程的本质就是一些系统内存，每个进程占据一定的资源。

2、线程

线程是指进程中的一个执行流程，进程中包含的一个或多个执行单元（子任务，线程）

一个进程中包含一到多个线程（但是不能一个都没有）。

二、线程的创建

线程的创建

1、方式一：继承Thread类

1.1、步骤

继承Thread类

（1）自定义线程类继承自Thread类

（2）重写run()方法，编写线程执行体

（3）创建线程对象，调用start()方法启动线程

1.2、 代码体现

//创建线程方式一：继承Thread类，重新run()方法，调用start开启线程
//总结：线程调用不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i <200 ; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程 主线程
        //创建一个Thread对象
        Thread testThread1 = new TestThread1();
        //调用start方法开启线程
        testThread1.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

2、方式二：实现Runable接口

2.1、步骤

实现Runable接口

（1）自定义MyRunable类实现Runable接口

（2）重写run()方法，编写线程执行体

（3）创建线程对象，调用start()方法启动线程

2.2、 代码体现

//创建线程方式二：实现Runable接口，重写run方法
public class TestThread02 implements Runnable{
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i <200 ; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程 主线程
        //创建Runable接口的实现类对象
        TestThread02 testThread02 = new TestThread02();
        //创建线程对象，通过线程对象来开启线程 代理
        new Thread(testThread02).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程" + i);
        }
    }
}

3、方式三：实现Callable接口

3.1、步骤

（1）实现Callable接口，需要返回值类型

（2）重写call()方法，抛出异常

（3）创建目标对象 TestCallable t1 = new TestCallable();

（4）创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(1);

（5）提交执行 Future r1 = ser.submit(t1);

（6）获取结果 boolean rs1 = r1.get();

‘（7）关闭服务 ser.shutdownNow();

3.2、 代码体现

//创建线程方式三：实现Callable接口，重写call方法
//实现Callable接口  实现多线程同步下载图片
public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;

    public TestCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() throws Exception {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoader(url,name);
        System.out.println("下载了文件名为"+name);
        return true;
    }
    //主线程
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://ss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=1561383303,2055953075&fm=26&gp=0.jpg","1.jpg");
        TestCallable t2 = new TestCallable("https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=3258014100,3780692077&fm=26&gp=0.jpg","2.jpg");
        TestCallable t3 = new TestCallable("https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=3565814160,3345825283&fm=26&gp=0.jpg","3.jpg");
        //1、创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //2、提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //3、获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r1.get();
        boolean rs3 = r1.get();
        //4、关闭服务
        ser.shutdownNow();
    }
}

//下载工具类
public class WebDownloader{
    //url:远程路径 name：文件名字
    public void downLoader(String url,String name){
        try {
            //FileUtils文件工具，复制文件
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，文件下载失败");
        }
    }
}

4、总结

开发中，优先选择实现Runable接口的方式

• 实现的方式没有类的单继承性的局限性
• 实现的方式更适合用来处理多个线程有共享数据的情况，方便同一个对象被多个线程调用

三、代理模式

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象。

这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。

• 静态代理代理类在编译期就生成

• 动态代理代理类则是在Java运行时动态生成。

1、静态代理

由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了.

静态代理

静态代理角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现
• 真实角色 : 被代理的角色
• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
• 客户 : 使用代理角色来进行一些操作 .

代码实现

//抽象角色：租房
public interface Rent {
    public void rent();
}

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

//代理角色：中介
public class Proxy implements Rent {
    private Host host;
    public Proxy() { }
    public Proxy(Host host) {
        this.host = host;
    }
 
    //租房
    public void rent(){
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

//客户类，一般客户都会去找代理！
public class Client {
    public static void main(String[] args) {
        //房东要租房
        Host host = new Host();
        //中介帮助房东
        Proxy proxy = new Proxy(host);
 
        //你去找中介！
        proxy.rent();
    }
}

2、动态代理

在程序运行时，运用反射机制动态创建而成。

为什么要使用动态代理

• 代理对象的一个接口只服务于一种类型的对象，当代理的方法很多时，就要为每一种方法都进行代理，代码冗余大。
• 当接口中增加方法时，除了实现类要实现这个方法，所有代理类也需要实现此方法，增加了代码维护的复杂度。

动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

• 基于接口的动态代理----JDK动态代理
• 基于类的动态代理--cglib

代码实现

//抽象角色：租房
public interface Rent {
    public void rent();
}

//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

//代理角色：中介
public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;
 
    public void setRent(Rent rent) {
        this.rent = rent;
    }
 
    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }
 
    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本质利用反射实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }
 
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

//租客
public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //将真实角色放置进去！
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }
}

3、使用场景

• 代理单个目标对象——使用静态代理
• 代理多个目标对象——使用动态代理

四、Lambda表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

• 避免匿名内部类定义过多
• 使用 Lambda 表达式可以使代码变的更加简洁紧凑。
• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
• Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

1、语法

(parameters) -> expression[表达式]
或
(parameters) ->{ statements[语句]; }

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

2、使用

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

3、函数式接口

只有一个 抽象方法 （Object类中的方法除外）的接口是函数式接口

• 只能有一个抽象方法，没有抽象方法或者有多个抽象方法的接口都不是函数式接口。

• 必须是抽象方法，如果接口里面只有一个静态方法或者default方法，都不是函数式接口。

• 如果接口里面只有一个抽象方法，但是这个抽象方方法是Object类中的方法，如hashCode方法，这个接口也不是函数式接 口。

4、使用Lambda表达式实现函数式接口

public class testlambda {
    public static void main(String[] args) {
        ILove love = (int a)->{
            System.out.println("i love number"+a);
        };
        love.love(14);

    }
}

interface ILove{
    void love(int a);
}

//使用Lambda表达式实现函数式接口
public class testlambda2 {
    public static void main(String[] args) {
        //简化1
        ILove love = null;
        love = a -> {
            System.out.println("i love "+a);
        };
        love.love(5);
        //简化2
        love = a -> System.out.println("i love aa"+a);
        love.love(520);
    }
}

interface ILove{
    void love(int a);
}

五、线程的生命周期（状态）

线程的生命周期

六、线程的常用方法

• Thread.currentThead（）：获取当前线程对象
• getPriority（）：获取当前线程的优先级
• setPriority（）：设置当前线程的优先级(线程优先级高，被CPU调度的概率大，但不代表一定会运行，还有小概率运行优先级低的线程。)
• isAlive（）：判断线程是否处于活动状态 （线程调用start后，即处于活动状态）
• join（）：调用join方法的线程强制执行，其他线程处于阻塞状态，等该线程执行完后，其他线程再执行。有可能被外界中断产生InterruptedException 中断异常。
• sleep（）：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。休眠的线程进入阻塞状态。
• yield（）：调用yield方法的线程，会礼让其他线程先运行。（大概率其他线程先运行，小概率自己还会运行）
• interrupt()：中断线程
• wait（）：导致线程等待，进入堵塞状态。该方法要在同步方法或者同步代码块中才使用的
• notify（）：唤醒当前线程，进入运行状态。该方法要在同步方法或者同步代码块中才使用的
• notifyAll（）：唤醒所有等待的线程。该方法要在同步方法或者同步代码块中才使用的

七、线程同步

多个线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没得到最新的数据，从而产生线程安全问题。

通过同步机制，来解决线程的安全问题。

1、同步代码块

即有synchronized关键字修饰的语句块。
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

synchronized(object){
}

代码体现

public class SyncThreadDemo {

    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        new Thread(mr).start();
        new Thread(mr).start();
    }

}

class MyRunnable implements Runnable {

    private int tickts = 10;

    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            if (tickts > 0) {
            // 方法一：使用同步代码块
            synchronized (this) {
                System.out.println("第" + (tickts--) + "张票售出");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }   
    }
}

2、同步方法

即有synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

public synchronized void save(){}
//synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

代码体现

public class SyncThreadDemo {

    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        new Thread(mr).start();
        new Thread(mr).start();
    }
}

class MyRunnable implements Runnable {

    private int tickts = 10;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 方法二：使用同步方法达到线程安全
            saleTickts();       
        }
    }

    // 同步方法：同步的是当前对象
    private synchronized void saleTickts() {
        if (tickts > 0) {
            System.out.println("第" + (tickts--) + "张票售出");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

3、Lock锁

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，
它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力

ReenreantLock类的常用方法有：

• ReentrantLock() : 创建一个ReentrantLock实例
• lock() : 获得锁
• unlock() : 释放锁

代码体现

public class SyncThreadDemo {

    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        new Thread(mr).start();
        new Thread(mr).start();
    }

}

class MyRunnable implements Runnable {

    private int tickts = 10;

    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            // 方法三：使用ReentrantLock，更加灵活，可以加入判断，在特定的情况下释放锁
            saleTickts2();
        }
    }
    ReentrantLock lock = new ReentrantLock();
    // 方法三：使用ReentrantLock，更加灵活，可以加入判断，在特定的情况下释放锁
    private void saleTickts2() {
        lock.lock();
        try {
            if (tickts > 0) {
                System.out.println("第" + (tickts--) + "张票售出");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 保证锁一定会被释放，不会出现死锁情况
        } finally {
            lock.unlock();// 释放锁
        }
    }
}

4、三种比较

优先级 Lock > 同步代码块 > 同步方法

• 如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码
• 通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可
• 如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁

5、死锁

死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。

死锁产生的必要条件：

（1）互斥条件：在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

（2）不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。

（3）请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。

（4）循环等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。

产生死锁必须同时满足以上四个条件，只要其中任一条件不成立，死锁就不会发生。

我们只需要破坏其中的一个或多个条件就可以避免死锁发生

八、线程通信

通信方式

1. wait()：先释放资源，并开始等待
2. wait(long timeout)：释放资源等待timeout秒
3. notify()：唤醒一个处于等待状态的线程
4. notifyAll()：唤醒同一个对象上所有调用了wait()方法的线程，优先级高的优先调度
5. 缓冲区（消息队列）
6. 标志位：红绿灯

九、线程池

• 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

• 提前创建好多个线程，放入线程池中，使用时直接获取,使用完放回池中，可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具

• 好处

  • 提高响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
  • 便于线程管理
    • corePoolSize:核心池的大小
    • maximumPoolSize: 最大线程数
    • keepAliveTime: 线程没有任务时最多保持多长时间后会终止

• 代码体现

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        ExecutorService service= Executors.newFixedThreadPool(10);
        //newFixedThreadPool 参数为：线程池大小
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}