Java多线程学习-CSDN博客

本文链接：https://blog.csdn.net/2301_79469341/article/details/145294341

线程相关概念

线程：是进程的一部分，一个进程之内的线程之间共享进程的地址空间、资源。
进程：一个进程可以包含干个线程，但至少有一个线程(线程是CPU调度和执行的单位)。每个进程有独立的地址空间、全局变量、系统资源。是系统资源分配的单位。
多线程：一个进程中并发多个线程，每个线程执行不同任务。

很多多线程是模拟出来的。真正的多线程是指有多个CPU(即多核，多服务)。如果是模拟出来的线程，即在一个cpu的情况下，在同一时间点，cpu只能执行一个代码，因为切换的很快，造成同时执行的错觉。

相关概念

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

线程创建

三种创建方式：

Thread class(继承Thread类)
Runnable接口(实现Runnable接口)
Callable接口(实现Callable接口，了解即可)

继承Thread类

自定义线程类继承Thread类

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

package ThreadStudy;
//继承Thread类
public class ThreadTest01 extends Thread{
    @Override
    public void run(){
        //run()方法线程体
        for(int i=0;i<10;i++){
            System.out.println("run"+i);
        }
    }

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

        for(int i=0;i<10;i++){
            System.out.println("主线程"+i);
        }
    }
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

总结：线程开启不一定立即执行，这个由CPU进行调度。

案例：下载图片

package ThreadStudy;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.security.spec.RSAOtherPrimeInfo;
//实现多线程同步下载图片
public class DownloadTest extends Thread{

    private String url;//图片地址
    private String name;//保存的文件名
    public DownloadTest(String url,String name){
        this.name=name;
        this.url=url;
    }
    @Override
    public void run(){
        webDownloader webDownloader=new webDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为:"+name);
    }

    public static void main(String[] args) {
        DownloadTest t1=new DownloadTest("https://img30.360buyimg.com/security/jfs/t1/106812/11/17157/47913/5e859436E81f1efd9/c6c4cf56305d75d2.jpg","1.jpg");
        DownloadTest t2=new DownloadTest("https://img30.360buyimg.com/security/jfs/t1/100763/10/17328/48613/5e85946eEd153e514/8ffec9a8e7832567.jpg","2.jpg");
        DownloadTest t3=new DownloadTest("https://img30.360buyimg.com/security/jfs/t1/98816/36/17526/48339/5e8594a8E4e154c27/42afb9370b45dab5.jpg","3jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器
class webDownloader{
    //下载方法
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

可以看到下载不是按照顺序下载的

Runnable接口

定义MyRunnable类实现Rnnable接口

实现run()方法，编写线程执行体

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

package ThreadStudy;

public class TestRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("run"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestRunnable testRunnable=new TestRunnable();

        //创建线程对象，通过线程对象开启线程，代理
        //相当于:
        //Thread thread=new thread(testRunnable);\
        //thread.start();
        new Thread(testRunnable).start();

        for(int i=0;i<20;i++){
            System.out.println("main"+i);
        }
    }
}

使用Runnable接口实现下载图片：
只需要将继承Thread改为实现Runnable接口，再改一下start()部分即可

package ThreadStudy;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.security.spec.RSAOtherPrimeInfo;
//实现多线程同步下载图片
public class DownloadTest implements Runnable{

    private String url;//图片地址
    private String name;//保存的文件名
    public DownloadTest(String url,String name){
        this.name=name;
        this.url=url;
    }
    @Override
    public void run(){
        webDownloader webDownloader=new webDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为:"+name);
    }

    public static void main(String[] args) {
        DownloadTest t1=new DownloadTest("https://img30.360buyimg.com/security/jfs/t1/106812/11/17157/47913/5e859436E81f1efd9/c6c4cf56305d75d2.jpg","1.jpg");
        DownloadTest t2=new DownloadTest("https://img30.360buyimg.com/security/jfs/t1/100763/10/17328/48613/5e85946eEd153e514/8ffec9a8e7832567.jpg","2.jpg");
        DownloadTest t3=new DownloadTest("https://img30.360buyimg.com/security/jfs/t1/98816/36/17526/48339/5e8594a8E4e154c27/42afb9370b45dab5.jpg","3jpg");

        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

//下载器
class webDownloader{
    //下载方法
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

小结：
继承Thread类

子类继承Thread类，具备多线程能力
启动线程：子类对象.start()
不建议使用：避免OOP单继承局限性

实现Runnable接口

实现接口Runnable具有多线程能力
启动线程：传入目标对象+Thread(对象).start()
推荐使用：避免单继承局限性，灵活，方便同一个对象被多个线程使用

多个线程同时操作同一个对象测试：

package ThreadStudy;
//多个线程同时操作同一个对象
//模拟买票的例子
//发现问题：多个线程操作同一个资源时，线程不安全，数据紊乱
public class ThreadTest01 implements Runnable{

    private int ticketNums=10;

    @Override
    public void run(){
        while(true){
            if(ticketNums<1){
                break;
            }
            //模拟延时
            try{
                Thread.sleep(200);
            }catch(Exception e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        ThreadTest01 ticket=new ThreadTest01();

        //创建线程对象，通过线程对象开启线程
        new Thread(ticket,"A").start();
        new Thread(ticket,"B").start();
        new Thread(ticket,"C").start();

    }
}

案例：龟兔赛跑

package ThreadStudy;
//模拟龟兔赛跑
public class Race implements Runnable{
    private static String winner;
    @Override
    public void run(){
        for(int i=0;i<=100;i++){
            //模拟兔子休息
            if(Thread.currentThread().getName().equals("rabbit")&&i%10==0){
                try{
                    Thread.sleep(1);
                }catch(Exception e){
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag=gameOver(i);
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        if(winner!=null){
            return true;
        }{
            if(steps>=100){
                winner=Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race,"rabbit").start();
        new Thread(race,"turtle").start();
    }
}

实现callable接口(了解)

实现callable接口需要返回值类型

重写call方法，需要抛出异常

创建目标对象

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

提交执行:Future result1=ser.submit(t1);

获取结果:boolean r1=result1.get()

关闭服务:ser.shutdownNow();

package ThreadStudy;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.security.spec.RSAOtherPrimeInfo;
import java.util.concurrent.*;

//实现多线程同步下载图片
public class TestCallable implements Callable<Boolean> {

    private String url;//图片地址
    private String name;//保存的文件名
    public TestCallable(String url,String name){
        this.name=name;
        this.url=url;
    }
    @Override
    public Boolean call(){
        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://img30.360buyimg.com/security/jfs/t1/106812/11/17157/47913/5e859436E81f1efd9/c6c4cf56305d75d2.jpg","1.jpg");
        TestCallable t2=new TestCallable("https://img30.360buyimg.com/security/jfs/t1/100763/10/17328/48613/5e85946eEd153e514/8ffec9a8e7832567.jpg","2.jpg");
        TestCallable t3=new TestCallable("https://img30.360buyimg.com/security/jfs/t1/98816/36/17526/48339/5e8594a8E4e154c27/42afb9370b45dab5.jpg","3jpg");

        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1=ser.submit(t1);
        Future<Boolean> r2=ser.submit(t2);
        Future<Boolean> r3=ser.submit(t3);
        //获取结果
        boolean rs1=r1.get();
        boolean rs2=r2.get();
        boolean rs3=r3.get();
        //关闭服务
        ser.shutdownNow();
    }
}

//下载器
class webDownloader{
    //下载方法
    public void downloader(String url,String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

静态代理

package ThreadStudy;

//静态代理模式
public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingcompany=new WeddingCompany(new You());
        weddingcompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

class You implements Marry{
    @Override
    public void HappyMarry(){
        System.out.println("happy");
    }
}

class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target){
        this.target=target;
    }
    @Override
    public void HappyMarry(){
        before();
        this.target.HappyMarry();
        after();
    }
    private void before(){
        System.out.println("结婚之前，布置现场");
    }
    private void after(){
        System.out.println("结婚之后，收尾款");
    }
}

静态代理总结：

真实对象和代理对象都要实现同一个目标，代理对象要代理真实角色

代理对象可以实现真实对象实现不了的功能，真实对象专注自己的功能

lamda表达式

为了避免匿名内部类定义过多，可以使代码看起来更简洁，其实质属于函数式编程。

**函数式接口定义：**只包含唯一一个抽象方法，那么它就是函数式接口。

public interface Runnable{
    public abstract vvoid run();
}

对于函数式接口，可以通过lamda表达式创建该接口的对象。

格式：

(params) -> expresssion[表达式]
    (params)->statement[语句]
    	(params)->{statements}

package lamda;

/*
推导lamda表达式
*/
public class TestLamda {

    //2、静态内部类
    static class Like2 implements ILike{
        @Override
        public void lamda(){
            System.out.println("test lamda2");
        }
    }

    public static void main(String[] args) {
        ILike like =new Like1();
        like.lamda();

        like =new Like2();
        like.lamda();

        //3、局部内部类
        class Like3 implements ILike{
            @Override
            public void lamda(){
                System.out.println("test lamda3");
            }
        }

        like=new Like3();
        like.lamda();

        //4、匿名内部类,没有类的名称，必须借助接口或父类
        like=new ILike(){
            @Override
            public void lamda(){
                System.out.println("test lamda4");
            }
        };
        like.lamda();

        //5、lamda简化
        like=()->{
            System.out.println("test lamda5");
        };
        like.lamda();

    }
}

//0、定义一个函数式接口
interface ILike{
    void lamda();
}

//1、实现类
class Like1 implements ILike{
    @Override
    public void lamda(){
        System.out.println("test lamda1");
    }
}

线程状态

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

线程方法

方法	说明
setPriority(int new Priority)	更改线程优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程（尽量别用这个方式）
boolean isAlive()	测试线程是否处于活动状态

线程停止

尽量使线程自动停止(通过设置标记位来终止变量，当flag=false，线程停止)

不要使用stop或destroy这种过时的方法

package status;


//
public class TestStop implements Runnable{

    //标志位
    private Boolean flag=true;
    @Override
    public void run(){
        int i=0;
        while(flag){
            System.out.println("run...Thread"+i++);
        }
    }

    //设置停止方法
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        TestStop teststop=new TestStop();
        new Thread(teststop).start();

        for(int i=0;i<999;i++){
            System.out.println("main"+i);
            if(i==900){
                teststop.stop();
                System.out.println("该线程停止了");
            }
        }
    }
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

线程休眠 sleep()

sleep指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后，线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每个对象都有一个锁，sleep不会释放锁

package status;

public class TestSleep2 {

    public static void tenDown() throws InterruptedException{
        int num=10;

        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<0){
                break;
            }
        }
    }
    public static void main(String[] args) {
        try{
            tenDown();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

package status;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep3{

    public static void main(String[] args) {
        Date startTime=new Date(System.currentTimeMillis());
        while(true){
            try{
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新当前时间
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
    
}

线程礼让 yield()

让当前正在执行的线程暂停，但不阻塞，将线程从运行状态转为就绪状态。(让cpu重新调度，礼让不一定成功)

package status;

//测试礼让线程(不一定成功，看CPU心情)
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield =new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }

}

class MyYield implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

线程强制执行 join()

join合并线程，等待此线程执行完成后，再执行其他线程，其他线程阻塞(可以想象成插队)

package status;

// 测试 join 方法 (插队)
public class TestJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程 vip 来了 " + i);
            try {
                Thread.sleep(10); // 增加延时，模拟更耗时的任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin); // 定义线程对象
        thread.start(); // 启动线程

        // 主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join(); // 插队
            }
            System.out.println("main " + i);
        }
    }

}

观测线程状态

Thread.state

NEW：尚未启动的线程处于此状态
RUUNABLE：java虚拟机中执行的线程处于此状态
BLOCKED：被阻塞等待监视器锁定的线程处于此状态
WAITING：正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED：已退出的线程处于此状态

package status;

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println(".........");
        });

        //观察状态
        Thread.State state=thread.getState();
        System.out.println(state);

        //观察启动后
        thread.start();
        state=thread.getState();
        System.out.println(state);

        while(state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state=thread.getState();
            System.out.println(state);
        }
    }
}
//输出：
NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
.........
TERMINATED

进程已结束，退出代码为 0

线程优先级

线程调度器按照优先级来决定调度哪个线程来执行，线程优先级用数字1~10表示

三个优先级常量：
Thread.MIN_PRIORITY=1;
Thread.MAX_PRIORITY=10;
Thread.NORM_PRIORITY=5;

使用getPriority()获取优先级，使用.setPriority(int xxx)设定优先级

package status;

public class TestPriority {
    //主线程默认优先级
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MyPriority myPriority=new MyPriority();

        Thread t1=new Thread(myPriority);
        Thread t2=new Thread(myPriority);
        Thread t3=new Thread(myPriority);
        Thread t4=new Thread(myPriority);

        t1.setPriority(Thread.MIN_PRIORITY);//1
        t1.start();

        t2.setPriority(3);
        t2.start();

        t3.setPriority(Thread.NORM_PRIORITY);//5
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//10
        t4.start();
    }
}

//测试线程优先级
class MyPriority implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

//输出：
main-->5
Thread-3-->10
Thread-2-->5
Thread-1-->3
Thread-0-->1

守护线程

线程分为：用户线程(main)和守护线程(gc)

虚拟机必须确保用户线程执行完毕，但不用等待守护线程执行完毕。

守护线程通常用于后台记录操作日志、监控内存、垃圾回收等待

package status;

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        God god=new God();
        You you=new You();

        Thread thread=new Thread(god);
        thread.setDaemon(true);//默认为false表示用户线程

        thread.start();//上帝守护线程启动

        new Thread(you).start();//你，用户线程启动
    }
}

//上帝
class God implements Runnable{
    @Override
    public void run(){
        while(true){
            System.out.println("上帝保佑你");
        }
    }
}
//你
class You implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 36500; i++) {
            System.out.println("开心的活着");
        }
        System.out.println("-------goodbye!Gameover!----------");
    }
}

线程同步

并发：同一个对象被多个线程同时操作。

例如：多人抢同一张票，两个银行同时取钱等等

**线程同步：**是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。

形成条件：队列+锁

为了保证数据在方法中被访问时的正确性，在访问时加入锁机制(synchronized)，当线程获得对象的排他锁，独占资源，其他线程必须等待使用后释放锁才行。但也会导致一些不安全的案例

三大不安全案例

1、不安全的买票

package syn;

//不安全买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();

        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums=10;
    Boolean flag=true;

    @Override
    public void run(){
        //买票
        while(flag){
            try{
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    private void buy() throws InterruptedException{
        //判断是否有票
        if(ticketNums<=0){
            return;
        }
        Thread.sleep(1000);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

2、不安全的取钱

package syn;

//不安全的取钱，两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account=new Account(1000,"结婚基金");

        Drawing you =new Drawing(account,50,"你");
        Drawing girlFriend =new Drawing(account,100,"girlFriend");

        you.start();
        girlFriend.start();

    }
}

//账户
class Account{
    int money;
    String name;
    public Account(int money,String name){
        this.money=money;
        this.name=name;
    }
}
//银行，模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取钱数
    int nowMoney;//现在手里的钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;
    }

    //取钱
    @Override
    public void run(){
        if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }

            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            //卡内余额=余额-你取的钱
            account.money=account.money- drawingMoney;
            //你手里的钱
            nowMoney=nowMoney+drawingMoney;

            System.out.println(account.name+"余额为:"+account.money);
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
}

3、不安全的集合

package syn;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();

        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try{
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

同步方法及同步块

只读的部分不需要同步，修改的部分才需要同步

**同步方法：**在方法前面加上synchronized关键字即可保证线程安全

package syn;

//不安全买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();

        new Thread(buyTicket,"A").start();
        new Thread(buyTicket,"B").start();
        new Thread(buyTicket,"C").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums=10;
    Boolean flag=true;

    @Override
    public void run(){
        //买票
        while(flag){
            try{
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    //synchronized 同步方法,锁的是this
    private synchronized void buy() throws InterruptedException{
        //判断是否有票
        if(ticketNums<=0){
            return;
        }
        Thread.sleep(1000);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

同步块：synchronized(Obj){ }，其中Obj为同步监视器，其可以是任何对象(推荐使用共享资源作为同步监视器)。同步方法中不需要指定同步监视器，因为同步方法的同步监视器就是this，即该对象本身或class。

即要锁的是需要增删改的对象。

同步监视器执行过程：

1、第一个线程访问，锁定同步监视器，执行其中的代码

2、第二个线程访问，发现同步监视器被锁定，无法访问

3、第一个线程访问完毕，解锁同步监视器

4、第二个线程访问，发现同步监视器没有锁，然后锁定并访问

package syn;

//不安全的取钱，两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account=new Account(1000,"结婚基金");

        Drawing you =new Drawing(account,50,"你");
        Drawing girlFriend =new Drawing(account,100,"girlFriend");

        you.start();
        girlFriend.start();

    }
}

//账户
class Account{
    int money;
    String name;
    public Account(int money,String name){
        this.money=money;
        this.name=name;
    }
}
//银行，模拟取款
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//取钱数
    int nowMoney;//现在手里的钱

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;
    }

    //取钱
    @Override
    public void run(){
		
        //加入synchronized锁住块
        synchronized (account){
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }

            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            //卡内余额=余额-你取的钱
            account.money=account.money- drawingMoney;
            //你手里的钱
            nowMoney=nowMoney+drawingMoney;

            System.out.println(account.name+"余额为:"+account.money);
            System.out.println(this.getName()+"手里的钱"+nowMoney);
        }
        }
}

package syn;

import java.util.concurrent.CopyOnWriteArrayList;

// 测试 JUC 安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        // 使用线程安全的 CopyOnWriteArrayList
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

        // 创建 10000 个线程向集合中添加数据
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }

        // 主线程等待所有子线程执行完毕
        try {
            Thread.sleep(2000); // 增加等待时间，确保线程执行完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("集合大小: " + list.size());
    }
}

死锁

导致两个或多个线程都在等待对方释放资源，都停止执行的情形，即某个同步块同时拥有“两个以上对象的锁”时，就可能导致死锁

死锁产生的四个必要条件：
1、互斥条件：一个资源每次只能被一个进程使用

2、请求与保持条件：一个进程因请求资源而阻塞时，对已经获得的资源保持不放

3、不剥剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺

4、循环等待条件：若干进程之间形成一种头尾相接的循环等待资源

避免死锁条件：破除其中之一即可

package ThreadStudy;

// 死锁，多个线程互相抱着对象需要的资源，形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(0, "A");
        Makeup girl2 = new Makeup(1, "B");

        girl1.start();
        girl2.start();
    }
}

// 口红
class Lipstick {

}

// 镜子
class Mirror {

}

class Makeup extends Thread {
    // 用 static 保证资源只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlName;

    Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;

    }

    @Override
    public void run() {
        // 化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 化妆，互相持有对方的锁
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) { // 获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror) { // 一秒后获得镜子的锁
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        } else {
            synchronized (mirror) { // 先获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick) { // 一秒后获得口红的锁
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

//输出：
B获得镜子的锁
A获得口红的锁
并且一直卡死

解决方法：不抱对方的锁即可

private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) { // 获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror) { // 一秒后获得镜子的锁
                    System.out.println(this.girlName + "获得镜子的锁");
                }
        } else {
            synchronized (mirror) { // 先获得镜子的锁
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(2000);
            }
            synchronized (lipstick) { // 一秒后获得口红的锁
                    System.out.println(this.girlName + "获得口红的锁");
                }
        }
    }

Lock锁

jdk5.0开始，java提供了更强大的线程同步机制，通过显示定义同步锁对象来实现同步，同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应该先获取Lock对象。
ReentrantLock类实现Lock，可以显式加锁、释放锁

package ThreadStudy;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2, "窗口1").start();
        new Thread(testLock2, "窗口2").start();
        new Thread(testLock2, "窗口3").start();
    }
}

class TestLock2 implements Runnable {

    private int ticketNums = 10;

    // 定义 ReentrantLock 锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                // 加锁
                lock.lock();
                if (ticketNums > 0) {
                    Thread.sleep(100); // 模拟卖票的延迟
                    System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticketNums-- + " 张票");
                } else {
                    break; // 退出循环
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 解锁
                lock.unlock();
            }
        }
    }
}

synchronized与Lock的区别：

Lock是显式锁(手动开关锁，不要忘记关锁)，synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少时间来调度线程，性能更好，有更好的拓展性
优先使用顺序:Lock > 同步代码块(已经进入了方法体，分配了相应资源) > 同步方法(在方法体之外)

线程协作

生产者消费者问题

生产消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

Java提供了以下几个方法解决线程之间通信的问题(均是Object类的方法，都只能在同步方法或同步代码块中使用)

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，于sleep不同，会是释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度

解决方法：

1、并发协作模型"生产者/消费者模式"---->管程法

2、并发协作模型"生产者/消费者模式"---->信号灯法

管程法

利用缓冲区解决：生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。

package ThreadStudy;

public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Producer(container).start();
        new Consumer(container).start();
    }
}

// 生产者线程
class Producer extends Thread {
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了 " + i + " 只鸡");
            container.push(new Chicken(i));
        }
    }
}

// 消费者线程
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了 " + container.pop().id + " 只鸡");
        }
    }
}

// 产品类
class Chicken {
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

// 缓冲区（共享资源）
class SynContainer {
    // 容器大小
    Chicken[] chickens = new Chicken[10];
    // 容器计数器
    int count = 0;

    // 生产者放入产品
    public synchronized void push(Chicken chicken) {
        while (count == chickens.length) { // 容器满了，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count] = chicken;
        count++;
        this.notifyAll(); // 通知消费者可以消费了
    }

    // 消费者消费产品
    public synchronized Chicken pop() {
        while (count == 0) { // 容器空了，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll(); // 通知生产者可以生产了
        return chicken;
    }
}

信号灯法

设立一个标志位

package ThreadStudy;

public class TestPC {
    public static void main(String[] args) {
        TV tv=new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//生产者：演员
class Player extends Thread{
    TV tv=new TV();
    public Player(TV tv){
        this.tv=tv;
    }
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("播放喜羊羊");
            }else{
                this.tv.play("广告");
            }
        }
    }
}

//消费者：观众
class Watcher extends Thread{
    TV tv=new TV();
    public Watcher(TV tv){
        this.tv=tv;
    }
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }

}
//产品：节目
class TV{
    //演员表演，观众等待
    //观众观看，演员等待
    String program; //表演的节目
    boolean flag=true;

    //表演
    public synchronized void play(String program){
        if(!flag){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了"+program);
        //通过观众观看
        this.notifyAll();
        this.program=program;
        this.flag=!this.flag;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try{
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了"+program);
        //通知演员表演
        this.notifyAll();
        this.flag=!this.flag;
    }
}

线程池

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池中。可以避免频繁创建、销毁，实现重复利用。

JDK5.0开始提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见子类：ThreadPoolExecuotr

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池。

package ThreadStudy;

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        ExecutorService service= Executors.newFixedThreadPool(10);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭连接
        service.shutdownNow();
    }
}

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