多线程

程序、进程、线程

在操作系统中运行的程序就是进程，比如QQ、播放器、游戏、IDE等等
一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕，等等

Process与Thread

说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。
注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。
线程

多线程

概念：

线程就是独立的执行路径；
在程序运行时，即使没有自己创建线程，后台也会有多个线程。如主线程、gc线程等；
main()称之为主线程，为系统的入口，用于执行整个程序；
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的；
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
线程会带来额外的开销，如cpu调度时间，并发控制开销；
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

实现多线程的三种方法：

1、继承Thread类 重写run方法 使用start开启线程

public class student extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我在玩手机");
        }
    }
}

public class Application {
    public static void main(String[] args) {
        student student = new student();
        student.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在玩看电视呢");
        }
}}

多线程下载图片

package oop;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class webdownloader extends Thread{
    private  String url;
    private  String file;

    public void webdownloader(String url,String file) {
        this.url=url;
        this.file=file;
    }

    @Override
    public void run() {
        loader loader = new loader();
        loader.loader(url,file);
        System.out.println("下载了"+file);
    }
}
class loader{
    public void loader(String url,String file) {
        try {
            FileUtils.copyURLToFile(new URL(url),new File(file));
        } catch (IOException e) {
            System.out.println("出现异常啦");
            throw new RuntimeException(e);
        }
    }
}

package oop;
import static java.lang.Math.random;
public class Application {
    public static void main(String[] args) {

        webdownloader t1 = new webdownloader();
        webdownloader t2 = new webdownloader();
        webdownloader t3 = new webdownloader();
        t1.webdownloader("https://i0.hdslb.com/bfs/banner/39bb071c9afff5fbb461107562a82b51a4b8e859.jpg@976w_550h_1c.webp","p1.jpg");
        t2.webdownloader("https://i0.hdslb.com/bfs/banner/5bce62f82a1def76993fd16fe058477c68f41021.jpg@976w_550h_1c.webp","p2.jpg");
        t3.webdownloader("https://i0.hdslb.com/bfs/archive/95fdcdf38b3d557c1ce9463cbae49f5bbafc0fd9.jpg@672w_378h_1c.webp","p3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }



}

输出：
下载了p3.jpg
下载了p1.jpg
下载了p2.jpg

实现Runnable接口，重写run方法，将实现的对象传递给Thread中

package oop;
import static java.lang.Math.random;
public class Application {
    public static void main(String[] args) {
        webdownloader t1 = new webdownloader();
        webdownloader t2 = new webdownloader();
        webdownloader t3 = new webdownloader();
     t1.webdownloader("https://i0.hdslb.com/bfs/banner/39bb071c9afff5fbb461107562a82b51a4b8e859.jpg@976w_550h_1c.webp","p1.jpg");
        t2.webdownloader("https://i0.hdslb.com/bfs/banner/5bce62f82a1def76993fd16fe058477c68f41021.jpg@976w_550h_1c.webp","p2.jpg");
        t3.webdownloader("https://i0.hdslb.com/bfs/archive/95fdcdf38b3d557c1ce9463cbae49f5bbafc0fd9.jpg@672w_378h_1c.webp","p3.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
}}

小结：推荐使用runnable接口，可以避免单继承的局限性

lambdar表达式

限制：接口中只能有一个约束的方法。

用途：当我们需要一个方法体仅仅使用一次的时候，可以大大简化代码量

public interface testInter {
    public abstract void fun1();
}

testInter inter = null;
        inter = () -> {
            System.out.println("有意思");
        };
        inter.fun1();

线程停止

线程需要手动的释放掉，但是不建议用thread中自带的stop方法，但是可以自己手动停止

package oop;
import static java.lang.Math.random;
public class Application {
    public static void main(String[] args) {
        Thread2 thread = new Thread2();
        new Thread(thread).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("也在runnnnnnnn"+i);
            if (i==60)thread.stop();
        }
    }}

package oop;

public class Thread2 implements  Runnable{
    boolean flag = true;
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            if (flag){System.out.println("runnnnnnnnnnThread"+i);}
            else break;
        }
    }
    public  void stop(){
        flag =false;
    }
}

线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞

将线程从运行状态转为就绪状态

让cpu重新调度，礼让不一定成功！要看cpu心情！

守护线程

package oop;
public class testpriority {
    public static void main(String[] args) {
        Thread god = new Thread(() -> {
            while (true) System.out.println("上帝会一直保佑你");
        });
        Thread you = new Thread(() -> {
            for (int i = 0; i <= 36500; i++) {
                System.out.println("每天都很开心的活着");
                if (i==36500) System.out.println("bye world~");
            }
        });
        god.setDaemon(true); // 默认的线程是false修改为true之后就变成了守护线程
        god.start();
        you.start();
    }
    }

线程锁

synchronized(object){}  注意：object是可以变的属性

自己带锁的数组CopyOnWriteArrayList

import java.util.concurrent.CopyOnWriteArrayList;
public class list {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList le = new CopyOnWriteArrayList();

            for (int i = 0; i < 10000; i++) {
                new Thread(()-> {
                    le.add(Thread.currentThread().getName());
                }).start();

                }
        Thread.sleep(200);
        System.out.println(le.size());
        }

死锁

每个对象都有一把自己的锁，当使用两个线程相互要使用对象对方对象的时候，这就会造成二者陷入矛盾中，这就是死锁，而解决死锁的方法也很简单，就是将两个对象独立出来

线程池

package Threadpool;

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

public class pool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new test());
        service.execute(new test());
        service.execute(new test());
        service.execute(new test());

        service.shutdown();
    }
}

class test implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}