java多线程

最新推荐文章于 2023-02-08 22:34:08 发布

木寒夏

最新推荐文章于 2023-02-08 22:34:08 发布

阅读量126

点赞数 1

文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_43920565/article/details/114760012

版权

多线程

程序进程线程

多线程：多条执行路径，主线程和子线程交替执行。

1.程序是指令和数据局的集合，静态概念

2.进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位。

3.一个进程可以有多个线程，线程是CPU调度和执行的单位。main函数就是主线程。

4.线程就是独立执行的路径。

5.在程序运行时，及时没有创建自己的线程，后台也会有多个线程。

6.main为主线程，为系统的入口，用于执行整个程序。

7.一个进程开辟多个线程，线程的运行由调度器安排调度

8.对统一份资源操作时，会存在资源抢夺的问题，需要加入并发控制

9.线程会带来额外的开销

10.每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程创建

1.继承Thread类

自定义线程类继承Thread类

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

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

例：交替执行

//创建线程方法1：继承Thread
//线程开启不一定马上执行，由cpu调度执行
public class Demo01 extends Thread{
    @Override
    public void run() {
       //run方法方法体
        for (int i = 0; i < 20; i++) {
            System.out.println("learn thread");
        }
    }

    public static void main(String[] args) {
        //main方法，主线程
        //创建线程对象，调用start方法开启线程
        Demo01 demo0=new Demo01();
        demo0.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我是主线程");
        }
    }
}

2.实现Runnable接口（**）

推荐使用，避免单继承局限性，方便一个对象被多个对象使用

Thread.currentThread().getName()获取当前执行线程名

Sleep()方法模拟线程延时

定义类实现Runnable接口

实现run()方法

执行线程需要丢入runnable接口实现类，调用start方法。

//创建线程方式2：实现runnable接口
public class Thread2 implements Runnable{

    @Override
    public void run() {
        //run方法方法体
        for (int i = 0; i < 1000; i++) {
            System.out.println("learn thread"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        Thread2 thread2=new Thread2();
        //创建线程对象，通过线程对象开启我们的线程，代理
        //new Thread(thread2).start();
        Thread thread=new Thread(thread2);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是主线程"+i);
        }
    }
}

例：多个线程操作一个对象

package Thread;
//多个线程同时操作同一个资源的情况下，线程不安全，数据紊乱
public class testThread3 implements Runnable{
    //票数
    private int ticket=10;
    @Override
    public void run() {
        while (true){
            //每拿一张票减1
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(ticket<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到第"+ticket--+"票");
        }
    }
    //多个线程同时操作同一个对象
    public static void main(String[] args) {
        testThread3 test=new testThread3();
        new Thread(test,"小明").start();
        new Thread(test,"老师").start();
        new Thread(test,"黄牛").start();
    }
}

例：龟兔赛跑
1.首先来个赛道距离

2.判断比赛是否结束

3.打印出胜利者

4.龟兔赛跑开始

5.模拟兔子睡觉

6.乌龟赢得比赛

package Thread;

public class Race implements Runnable{
    public static String winner;//静态常量，保证胜利者只有一个
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            //给兔子添加延迟，让乌龟赢
            if(Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag=gameover(i);
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    public boolean gameover(int step){
        //判断是否有胜利者
        //已经有胜利者
        if (winner != null) {
            return true;
        }
        else {
            //比赛每人100步，满一百步比赛结束
            if(step>=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,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

3.实现Callable接口

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

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

3.创建目标对象

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

5.提交执行： Future result=ser.sumbit();

6.获取结果：boolean r1=result.get();

7.关闭服务：ser.shutdownNow()

Callable好处：

（1）可以定义返回值

（2）可以抛出异常

package Thread;

import java.util.concurrent.*;

//线程创建方式3：实现Callable接口
public class Thread3 implements Callable {
    private int id;

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

    @Override
    public Object call() throws Exception {
        System.out.println("运行线程"+this.id);
       return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread3 thread1=new Thread3(1);
        Thread3 thread2=new Thread3(2);
        Thread3 thread3=new Thread3(3);
        //创建执行服务
        ExecutorService ser= Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> result1=ser.submit(thread1);
        Future<Boolean> result2=ser.submit(thread2);
        Future<Boolean> result3=ser.submit(thread3);
        //获取结果
        boolean r1=result1.get();
        boolean r2=result2.get();
        boolean r3=result3.get();
        //关闭服务
        ser.shutdownNow();
    }
}
结果：运行线程2
     运行线程1
     运行线程3

例：

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
    FutureTask<Integer> futureTask=new FutureTask<Integer>(new myThread3());
    new Thread(futureTask).start();
    Integer integer=futureTask.get();
        System.out.println(integer);
    }
}
class myThread3 implements Callable{
    @Override
    public Integer call() throws Exception {
        System.out.println("hello");
       return 100;
    }
}
结果：hello
100

静态代理模式

好处：代理对象可以做很多真实对象未实现的事情，真实对象专注做自己的事情

package Thread;
//真实对象和代理对象都要实现同一个接口
//代理对象必须有一个真实角色，将定义的接口变量作为自己的成员参数，（设计接口变量，传递的参数为真实对象）
//代理对象实例化，调用自己的构造函数，然后在继承接口的方法中可以调用自己拥有的成员变量（接口变量）实现接口的函数。
public class Staticproxy {
    public static void main(String[] args) {
         //thread也实现了Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("happy");
            }
        }).start();
        //new you()为真实对象，you可以抽象的看成接口marry的子类，子类转换成父类，直接转换
        // you中的marry()方法覆盖接口中的marry()方法，方法重写
        weddingCompany weddingcompany=new weddingCompany(new you());
        weddingcompany.marry();
    }
}

    interface marry{
        void marry();
    }
    //you是一个真实角色
class you implements marry{
    @Override
    public void marry() {
        System.out.println("恭喜");
    }
}
//weddingcompany是一个代理角色
class weddingCompany implements marry{
    //可以声明接口类型的变量(接口可以定义，但不能实例化)
    private marry target;
    public weddingCompany(marry target) {
        this.target = target;
    }

    @Override
    public void marry() {
        before();
        //这就是真实目标角色，调用的marry()实际是真实对象实现的接口的方法
        this.target.marry();
        after();
    }
    public void before(){
        System.out.println("结婚之前！");
    }
    public void after(){
        System.out.println("己婚之后！");
    }

}

Lambda表达式

函数式接口

任何接口如果只包含唯一个抽象方法，那它就是一个函数式接口，对于函数式接口，可以通过lambda表达式穿件该接口的对象 例：

抽象方法无参书写方式

package Thread;

import javax.xml.bind.SchemaOutputResolver;

/*
推到lambda表达式
 */
public class TestDemo4 {
    //3.静态内部类
 static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("hello world2");
        }
    }
    //4.局部内部类
    public static void main(String[] args) {
        ILike like=new Like();
        like.lambda();
        //静态内部类
        like=new Like2();
        like.lambda();
        //局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("Hello world3");
            }
        }
        like=new Like3();
        like.lambda();

        //5.匿名内部类，无类名，必须借助接口实现
        like=new ILike() {
            @Override
            public void lambda() {
                System.out.println("Hello world4");
            }
        };
        like.lambda();
        //6.lambda表达式简化
        like=() ->{
                System.out.println("hello world5");
            };
     like.lambda();
    }
}
//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{

    @Override
    public void lambda() {
        System.out.println("hello world");
    }
}

例：抽象方法有参书写方式

package Thread;

public class testDemo5 {
    //1.静态内部类
    static class Love1 implements Love{
        @Override
        public void Ilove(int a) {
            System.out.println("hello world"+a);
        }
    }

    public static void main(String[] args) {
        Love love=new ILove();
        love.Ilove(1);
        //2.静态内部类
        love=new Love1();
        love.Ilove(2);
        //3.局部内部类
        class Love3 implements Love{

            @Override
            public void Ilove(int a) {
                System.out.println("hello world"+a);
            }
        }
        love=new Love3();
        love.Ilove(3);
        //4.匿名内部类
        love=new Love() {
            @Override
            public void Ilove(int a) {
                System.out.println("hello world"+a);
            }
        };
        love.Ilove(4);
        //lambda表达式简化
        love=(int a) ->{
                System.out.println("hello world"+a);
        };
        love.Ilove(5);
    }
}
interface Love {
    void Ilove(int a);
}
class ILove implements Love{
    @Override
    public void Ilove(int a) {
        System.out.println("hello world"+a);
    }
}

例：有参的方法lambda表达式简化（接着上述例子），前提是函数式接口

 //lambda表达式去掉参数类型简化（多个参数也可以去掉参数类型，要去掉就都去了）
        love=(a) ->{
            System.out.println("hello world"+a);
        };
        love.Ilove(6);
 //lambda表达式去掉括号简化（多个参数必须去掉括号）
        love=a ->{
            System.out.println("hello world"+a);
        };
        love.Ilove(7);
//去掉花括号简化（代码只要一行才可以直接去）
        love=a -> System.out.println("hello world"+a);
        love.Ilove(8);

线程阻塞状态

在这里插入图片描述

总结：new新生->start就绪->cpu调度运行->线程终端或结束，进入死亡（->调用sleep(),wait()或同步锁定，线程进入阻塞状态阻塞时间解除后重新进入就绪状态）

线程方法

setPriority(int newPriority)更新线程的优先级

static void sleep(long millis):在指定毫秒内让线程休眠

void join():插队（等待该线程终止）

static void yield():插队（暂停当前正在执行的线程对象）

void interrupt():中断线程（不建议使用）

线程停止

不推荐使用JDK提供的stop(),destroy()方法
推荐线程自己停下来
建议使用一个标志位进行终止变量，当flag=false,则终止线程运行

package Thread;
//测试stop
//1.建议线程正常停止-->利用次数，不建议死循环
//2.设置一个标志位
public class Teststop implements Runnable{
//设置一个标志位
    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("线程开始运行"+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 < 10000; i++) {
        if(i==1000){
            //调用stop方法换标志位，让线程停止
            System.out.println("main"+i);
            teststop.stop();
            System.out.println("线程该停止了！");
            }
        }
    }
}

线程休眠

sleep(时间)指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
每个对象都有一把锁，sleep不会释放锁
可用于模拟网络延迟（例;多个线程使用同一个对象），放大问题的发生性。

例：模拟倒计时

package Thread;
/*
模拟倒计时
 */
public class Testsleep2 {
    public static void main(String[] args) {
        try {
            turndown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
   public static void turndown() throws InterruptedException {
       int num=10;
       while(true){
           Thread.sleep(1000);
           System.out.println(num--);
           if(num<=0){
               break;
           }
       }
   }
}

例：获取系统当前时间，进行计时

public class Testsleep2 {
    public static void main(String[] args) throws InterruptedException {
      //打印系统当前时间
        Date start=new Date(System.currentTimeMillis());
        while(true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(start));
            //更新当前时间
            start=new Date(System.currentTimeMillis());
        }
    }

线程礼让

让cpu重新进行调度，礼让不一定成功

public class Threadyield {
    public static void main(String[] args) {
        myyeild myyeild=new myyeild();
        new Thread(myyeild,"线程1").start();
        new Thread(myyeild,"线程2").start();
    }
    }
    class myyeild implements Runnable{

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

join(插队)

package Thread;
/*
测试join方法
 */
public class jointhread implements Runnable {

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        jointhread join = new jointhread();
        Thread thread = new Thread(join);
        thread.start();
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join();
            }
            System.out.println("main" + i);
        }

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("vip来了");
        }
    }
}

线程状态观测

Thread.state:线程状态参数

死亡之后的线程不能重新启动

package Thread;
/*
观察线程状态
 */
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();
                }
            }
        });
        //观察状态
        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);

        }
    }
}

线程优先级

线程优先级用数字表示，范围从1~10

getPriotity()

setpriority(int XXX)

先设置优先级再启动

先设置优先级再启动，线程优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，主要看cpu的调度。

package Thread;
/*
测试线程优先级
 */
public class Testpriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
        mypriority mypriority=new mypriority();
        Thread thread1=new Thread(mypriority);
        Thread thread2=new Thread(mypriority);
        Thread thread3=new Thread(mypriority);
        Thread thread4=new Thread(mypriority);
        Thread thread5=new Thread(mypriority);
        Thread thread6=new Thread(mypriority);
        //先设置优先级，再启动
        thread1.start();
        thread2.setPriority(1);
        thread2.start();
        thread3.setPriority(4);
        thread3.start();
        thread4.setPriority(10);
        thread4.start();
    }
    }
    class mypriority implements Runnable{

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"->"+Thread.currentThread().getPriority());
        }
    }

守护线程（daemon）

线程分为用户线程和守护线程
虚拟机确定用户线程执行完毕
虚拟机不用等待守护线程执行完毕
后台记录操作日志监控内存垃圾回收

设置守护线thread.setDaemon(true);

package Thread;
/*
测试守护线程
 */
public class Testdaemon {
    public static void main(String[] args) {
        god gods=new god();
        my mys=new my();
       Thread thread=new Thread(gods);
       //默认为false
       thread.setDaemon(true);
       //守护线程启动
       thread.start();
        //用户线程启动
        new Thread(mys).start();

    }
}
//上帝
class god implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("上帝保佑着你");
    }
}

//你
class my implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("happy everyday");
        }
        System.out.println("goodbye world");
    }
}

线程同步机制（队列加锁）

处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这些对象，这时需要线程同步，线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象等待吃形成队列，等待前面的线程执行完毕，先有个线程再使用。

队列和锁

synchronized锁机制，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用释放锁即可。

存在问题：一个线程持有锁会导致其他所有需要此锁的线程挂起。
多线程竞争下，枷锁释放锁会导师性能下降。
优先级高的线程等待优先级低的线程释放锁，会导致优先级倒置，因其性能问题。

线程不安全案例

sleep可以放大问题的安全性

例：银行取钱的不安全性案例

package Thread.Syn;
//不安全的取钱，两个人去银行取钱，
public class unbank {
    //账户
    public static void main(String[] args) {
        card cards=new card(100,"hello");
        bank bank=new bank(cards,50,"me");
        bank bank2=new bank(cards,100,"you");
        bank.start();
        bank2.start();
    }
    }
class card{
    int money;//余额
   String name;//卡名

    public card(int money,String name) {
        this.money = money;
        this.name=name;
    }

}
//银行模拟取款
class bank extends Thread{
    card cards;//账户
    int  drawingmney;//取了多少钱
    int nowmoney;//手中目前还有多少钱

    public bank(card cards,int drawingmoney,String name) {
        super(name);
        this.cards = cards;
        this.drawingmney=drawingmoney;
    }

    @Override
    //取钱
    public void run() {
        //判断账户中有没有钱
        if(cards.money-drawingmney<0){
            System.out.println("账户余额不够，不能进行取钱");
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-取得钱
        cards.money=cards.money-drawingmney;
        //你手里的钱
        nowmoney=nowmoney+drawingmney;
        System.out.println(cards.name+"余额"+cards.money);
        //次数：this.getNanme=Thread.currentThread.getName()，因为该类继承Thread
        System.out.println(this.getName()+"手里钱为"+this.nowmoney);
        }
}
结果：hello余额50
me手里钱为50
hello余额-50
you手里钱为100

例：买票的不安全性：因为每个线程都有自己的运行内存，线程运行时会把同一个数据都放置到各自的内存中，导致最终计算结果的不一致。

package Thread.Syn;

import com.sun.org.apache.bcel.internal.generic.RETURN;

/*
不安全的买票
线程不安全有负数
 */
public class unsafetyTicket {
    public static void main(String[] args) {
        myticket ticket=new myticket();
        Thread thread1=new Thread(ticket,"第一个人");
        Thread thread2=new Thread(ticket,"第二个人");
        Thread thread3=new Thread(ticket,"第三个人");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
class myticket implements  Runnable{
    private int ticketnum=10;
    //外部停止方式
    boolean flag=true;
    @Override
    public void run() {
        //买票
        while(flag){
            buy();
        }

    }
    public void buy(){
        //买票
        //判断是否有票
        if(ticketnum<0){
            flag=false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"买到了"+ticketnum--+"张票");
    }
}

例：线程不安全集合

/*
线程不安全的集合
 */
public class Unssafelist {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
               list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}
结果：9170

同步方法

Synchronized方法控制对象的访问，每个对象对应一把锁，每个Synchronized方法对必须获得调用该方法的对象的所才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁继续执行。

例：修改买票案例

class myticket implements  Runnable{
    private int ticketnum=10;
    //外部停止方式
    boolean flag=true;
    @Override
    //同步方法，锁的是this
    public synchronized void buy(){
        //买票
        //判断是否有票
        if(ticketnum<0){
            flag=false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"买到了"+ticketnum--+"张票");
    }
}
结果：第二个人买到了10张票
第一个人买到了9张票
第三个人买到了8张票
第三个人买到了7张票
第一个人买到了6张票
第二个人买到了5张票
第二个人买到了4张票
第三个人买到了3张票
第一个人买到了2张票
第二个人买到了1张票
第一个人买到了0张票

同步块

synchronized(obj){}

obj为同步监听器，可以是任何独享，同步方法中无需指定同步检同期，因为同步方法的同步监听器就是this，就是这个对象本身，或者是class

同步监听器的执行过程：

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

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

3.第一个线程执行完毕，解锁同步监听器

4，第二个线程访问，发现同步监听器没有锁，于是锁定然后访问

例：修改银行取钱不安全例子,因为是对card实例进行操作，所以在bank类中不能将run方法设置为同步方法，应使用同步块即将对账户cards的操作放在同步代码块中。

锁的对象就是变化的量，需要增删改。

  //取钱
    public void run() {
        //将账户锁定
        synchronized (cards) {
            //判断账户中有没有钱
            if (cards.money - drawingmney < 0) {
                System.out.println("账户余额不够，不能进行取钱");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额=余额-取得钱
            cards.money = cards.money - drawingmney;
            //你手里的钱
            nowmoney = nowmoney + drawingmney;
            System.out.println(cards.name + "余额" + cards.money);
            //次数：this.getNanme=Thread.currentThread.getName()，因为该类继承Thread
            System.out.println(this.getName() + "手里`钱为" + this.nowmoney);
        }
    }
结果：hello余额0
you手里`钱为100
me账户余额不够，不能进行取钱

例：修改不安全集合案例

package Thread.Syn;

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

/*
线程不安全的集合
 */
public class Unssafelist {
    public static void main(String[] args) throws InterruptedException {
        List<String> list=new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}
结果：10000

CopyOnWriterArrayList

package Thread.Syn;

import java.util.concurrent.CopyOnWriteArrayList;

//测试juc安全类型的集合
public class testjuc {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String >();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}
结果：10000

死锁

某一个同步块同时拥有两个以上对象的锁时，可能会发生死锁问题。

产生死锁的四个必要条件：

1.互斥条件：一个资源每次只能被一个进程使用

2.请求与保持条件：一个进程因请求资源而堵塞是，对已获得济源保持不放

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

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

package Thread.Syn;
/*
死锁：多个线程互相抱着对方需要的资源，形成僵持
 */
public class Deadlock {
    public static void main(String[] args) {
        Makeup Q1=new Makeup(0,"灰姑娘");
        Makeup Q2=new Makeup(1,"白雪公主");
        Q1.start();
        Q2.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+"获得口红的锁");
                }
            }
        }
    }
}
结果：白雪公主获得镜子的锁
灰姑娘获得口红的锁
 程序僵持....

修改：

//化妆：不持有对方的锁
    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锁

控制多个线程对共享资源进行访问，每次只有一个线程对Lock对象加锁。

ReentranLock（可重入锁）实现了Lock,可以显示加锁，释放锁。

package Thread;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2=new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements  Runnable{
 int ticketnum=10;
 //定义Lock锁
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try{
            lock.lock();//加锁
            if(ticketnum>0){

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(ticketnum--);
            }else {
                break;
            }
            }finally{
                //解锁
                lock.unlock();
            }
        }
    }
}
结果：10 9 8 7 6 5 4  3 2 1

synchronized和Lock的对比

Lock是显式锁，手动开启，手动关闭，Sychronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，Synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少时间调度线程，性能更好，有更好的可扩展性

优先使用顺序：

Lock->同步代码块（已经进入方法体，分配了相应资源）->同步方法（在方法体之外）

线程协作（**）

生产者消费者模式：

生产者和消费者之间共享同一个资源，并且在生产者与消费者之间项目号依赖，互为条件。
对于生产者，在没有生产产品之前，要通知消费者等待，而且生产了商品之后，又马上要通知消费者消费
对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的商品。
在生产者消费者问题中仅有Synchronized是不够的（只能实现线程同步，不能实现线程通信）

解决线程通信的方法

java提供的解决线程通信的方法

wait():表示线程一直在等待，直到其它线程通知时，与sleep()不同，会释放锁
wait(long timeout):指定等待的毫秒数
notify（）：唤醒处于等待状态的线程
notifyAll()：唤醒一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
注意均是object类的方法，都只能在同步方法或同步代码中使用。

解决方式1：设置一个缓冲区（管程法）

例：

package Thread;
/*
测试生产者消费者模型-》利用缓冲区解决，管程法
生产者
 */
public class TestPC {
    public static void main(String[] args) {
    Syncontainer container=new Syncontainer();
    new productor(container).start();
    new customer(container).start();
    }
}
//生产者
class productor extends  Thread{
    Syncontainer container;
    public productor(Syncontainer container){
        this.container=container;
    }
 //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i + "只鸡");
            try {
                container.push(new chicken(i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//消费者
class customer extends Thread{
    Syncontainer container;
    public customer (Syncontainer container){
        this.container=container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费了"+container.pop().id+"只鸡");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//产品
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) throws InterruptedException {
        //如果容器满了通知消费者消费产品
        if(count==chickens.length){
                this.wait();
        }
        //如果没有满，就要丢入产品
        chickens[count]=chicken;
        count++;

        //可以通知消费者消费
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized  chicken pop() throws InterruptedException {
        if(count==0){
            //通知生产者生产产品
            this.wait();
        }
        //此处count先减的原因是：数组下标从0开始，当有一只鸡时，其实是在数组小标为零处
        count--;
        chicken cust=chickens[count];
        //通知生产者生产
        this.notifyAll();
        return cust;
    }
}

解决方法2：信号灯法

例：

package Thread;
//生产者消费者问题：信号灯法：标志位解决
public class Testpc2 {
    public static void main(String[] args) {
        TV tv=new TV();
        new player(tv).start();
        new watcher(tv).start();
    }
}
//生产者->演员
class player extends Thread{
TV tv;
public player(TV tv){
    this.tv=tv;
}

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            if(i%2==0){
                try {
                    tv.play("hello播放中。。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            else{
                try {
                    this.tv.play("广告时刻。。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//消费者->观众
class watcher extends Thread{
    TV tv;
    public watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            tv.watch();

        }
    }
}
//节目
class TV {
    //演员表演，观众等待T
    //观众观看，演员等待F
    String voice;//表演的节目
    boolean flag = true;

    public synchronized void play(String voice) throws InterruptedException {
        if(!flag){
            //演员等待
            this.wait();
        }
        System.out.println("演员表演了" + voice);
        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        flag = !flag;
    }

    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了"+voice);
        //通知演员表演
        this.notifyAll();
        flag=!flag;
    }
}
结果：   
演员表演了hello播放中。。。。
观众观看了hello播放中。。。。
演员表演了广告时刻。。。。
观众观看了广告时刻。。。。
演员表演了hello播放中。。。。
观众观看了hello播放中。。。。
演员表演了广告时刻。。。。
观众观看了广告时刻。。。。
演员表演了hello播放中。。。。
观众观看了hello播放中。。。。

线程池

背景：经常创建销毁特别大的资源，比如并发情况下的线程，对性能影响很大

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池，实现重复利用

线程池相关API

ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor

void execute(Runnable command):执行任务命令，没有返回值，一般用来执行Runnable，将线程丢入线程池

Futuresubmit(Callable task):执行任务有返回值，一般用于执行Callable

void shutdown():关闭连接池

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

例：Runnable实现

package Thread;

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

/*
测试线程池
 */
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        ExecutorService service=Executors.newFixedThreadPool(10);
        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());

    }
}
结果：
pool-1-thread-2
pool-1-thread-4
pool-1-thread-1
pool-1-thread-3

木寒夏

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java多线程

多线程持续更新修改…程序进程线程多线程：多条执行路径，主线程和子线程交替执行。1.程序是指令和数据局的集合，静态概念2.进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位。3.一个进程可以有多个线程，线程是CPU调度和执行的单位。main函数就是主线程。4.线程就是独立执行的路径。5.在程序运行时，及时没有创建自己的线程，后台也会有多个线程。6.main为主线程，为系统的入口，用于执行整个程序。7.一个进程开辟多个线程，线程的运行由调度器安排调度8.对统一份资源操
复制链接

扫一扫