java多线程 皮毛 全

 

 

java多线程

【狂神说Java】多线程详解哔哩哔哩bilibili

深入浅出线程Thread类的start()方法和run()方法 - 简书 (jianshu.com)

1.初见

java的线程是通过java.lang.Thread类来实现的。每个线程都是通过某个特定Thread对象所对应的方法run（）来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。

 

狂神的两个小demo

demo01

第一个建立线程的方法

package com.kuang;
​
public class demo01 extends Thread{
    @Override
    //run方法可以理解为简单的一个函数并没有什么实际作用
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run-----" + i);
        }
    }
​
    public static void main(String[] args) {
​
        demo01 demo01 = new demo01();
​
        //start（）方法是启动这个线程
        demo01.start();
​
        for (int i = 0; i < 2000; i++) {
            System.out.println("主线程---" + i);
        }
​
​
    }
}
​

demo02

用Runable接口来实现

package com.kuang;
​
public class demo02 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程" + i);
        }
    }
​
    public static void main(String[] args) {
​
        //线程代理
        demo02 demo02 = new demo02();
        Thread thread = new Thread(demo02);
​
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("学习多线程 -------------" + i);
        }
    }
}
​

通过分析源码可以看出来

Thread继承了Runable的接口

image-20220408114207816

Runable接口实现了run（）方法

但是你的Thread才是线程，不能直接用Runable直接测试run方法，还得通过Thread来进行测试

 

image-20220408113337056

demo03

发现并发问题

一共5张票，但是三个人抢的话，都会遍历一个遍

package com.kuang;
​
public class demo03 implements Runnable{
​
    /**
     * 通过买票发现并发问题
     */
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + "抢到了第" + i + "票");
        }
    }
​
    public static void main(String[] args) {
        demo03 demo03 = new demo03();
​
        new Thread(demo03,"小米").start();
        new Thread(demo03,"小红").start();
        new Thread(demo03,"黄牛").start();
​
    }
}
​

结果：

小红抢到了第1票
黄牛抢到了第1票
小米抢到了第1票
黄牛抢到了第2票
小红抢到了第2票
黄牛抢到了第3票
小米抢到了第2票
黄牛抢到了第4票
黄牛抢到了第5票
小红抢到了第3票
小米抢到了第3票
小红抢到了第4票
小米抢到了第4票
小红抢到了第5票
小米抢到了第5票
​

显然不符合要求

demo04

利用多线程解决龟兔赛跑

package com.kuang;
​
public class demo04 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "米");
​
            if(win(i)){
                break;
            }
            if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0 )
            {
                try {
                    //模拟兔子休息
                    Thread.sleep(20000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
​
        }
​
    }
​
    public boolean win(int step)
    {
        if(step == 100)
        {
            System.out.println(Thread.currentThread().getName() + "获胜");
            return true;
        }
        return false;
    }
​
    public static void main(String[] args) {
        demo04 demo04 = new demo04();
​
        new Thread(demo04,"🐢").start();
        new Thread(demo04,"🐇").start();
​
​
    }
}
​

结果：

🐢跑了999米 🐢跑了1000米 🐇跑了996米 🐇跑了997米 🐇跑了998米 🐇跑了999米 🐇跑了1000米 🐢获胜

 

 

2.Lamda表达式

image-20220408150921758

演变过程！！

package com.kuang.lambda;
​
public class evolution {
​
    //2.2静态内部类
    static class Like2 implements llike {
​
        @Override
        public void lambda() {
            System.out.println("l like lambda2");
        }
    }
​
    public static void main(String[] args) {
        //2.3直接调用实现类
​
        Like1 like1 = new Like1();
        like1.lambda();
​
        Like2 like2 = new Like2();
        like2.lambda();
​
        //2.4局部内部类
        class Like3 implements llike {
            @Override
            public void lambda() {
                System.out.println("l like lambda3");
            }
        }
​
        Like3 like3 = new Like3();
        like3.lambda();
​
​
        //2.5匿名内部类，没有名称要借助接口，直接用接口书写
        llike llike4 = new llike() {
            @Override
            public void lambda() {
                System.out.println("l like lambda4");
            }
        };
        llike4.lambda();
​
        //2.6lambda表达式
        llike like = ()->{
            System.out.println("l like lambda5");
        };
        like.lambda();
​
​
​
    }
​
    //1.定义一个接口
    interface llike {
        void lambda();
    }
​
    //2.1实现接口
    static class Like1 implements llike {
        @Override
        public void lambda() {
            System.out.println("l like lambda1");
        }
    }
}

第二个例子最简化：

package com.kuang.lambda;
​
public class test {
    
    public static void main(String[] args) {
        ILove iLove = a-> System.out.println("i love" + a);
​
        iLove.love(2);
    }
}
​
interface ILove
{
    void love(int a);
}
​

3.静态代理

代理模式是常用的Java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

package com.kuang.static01;
​
public class marry {
​
    public static void main(String[] args) {
        //对比多线程,也是Runnable target静态代理
        new Thread(() -> System.out.println("asdasd")).start();
        
        weddingCompany weddingCompany = new weddingCompany(new you());
        
        weddingCompany.Marry();
    }
​
}
interface marryy{
    void Marry();
}
​
class you implements marryy{
​
    @Override
    public void Marry() {
        System.out.println("结婚啦");
    }
}
​
class weddingCompany implements marryy{
​
    private marryy target;
​
    public weddingCompany (marryy target){
        this.target = target;
    }
​
    @Override
    public void Marry() {
        this.target.Marry();
    }
}

image-20220408163329268

4.线程方法

 

线程停止：

    package com.kuang.test;
    
    public class stop implements Runnable{
    
        private boolean st = true;
    
        @Override
        public void run() {
            int i = 0;
            while (st)
            {
                i++;
                System.out.println("线程" + i);
            }
        }
    
        public void stopp()
        {
            this.st = false;
        }
    
        public static void main(String[] args) {
    
            stop stop = new stop();
            new Thread(stop).start();
            for (int i = 0; i < 1000; i++) {
    
                System.out.println("main" + i);
                if(i == 900){
                    System.out.println("--------------停止了-------------");
                    stop.stopp();
                }
    
            }
        }
    }

线程休眠：

package com.kuang.test;

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

public class testSleep {

    //倒计时
    public static void tendown() throws InterruptedException {
        int num = 10;
        while (true)
        {
            Thread.sleep(1000);
            System.out.println(num);
            num --;
            if(num <= 0)break;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //tendown();

        Date date = new Date(System.currentTimeMillis());
        while(true)
        {
            int num = 10;
            num --;
            Thread.sleep(1000);
            if(num <= 0)break;
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            date = new Date(System.currentTimeMillis());
        }

    }

}

线程礼让：

package com.kuang.test;

public class yield {

    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() + "结束执行");
    }
}

礼让可能成功，可能不成功

结果1：

b开始执行 a开始执行 b结束执行 a结束执行

结果2：

a开始执行 b开始执行 b结束执行 a结束执行

线程插队：

package com.kuang.test;

public class testJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
            System.out.println("vip来了" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {

        testJoin testJoin = new testJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            if(i == 100)
            {
                thread.join();
            }
            System.out.println("main" + i);
        }
    }
}

值得一提的是，小于100的时候这两个是并发处理的，但是的等于100后就会先执行线程里面方法，主线程就是在等待中

5.线程状态观察

1.创建状态

2.启动状态

3.运行状态

4.阻塞状态

5.死亡状态

image-20220408195045662

 

 

image-20220408195021304

 

 

6.线程同步

并发：同一个对象被多个线程使用

（一张票让多个人抢到）

 

package com.kuang.test;

public class BuyTickt {

    public static void main(String[] args) {
        Buy buy = new Buy();

        new Thread(buy,"我").start();
        new Thread(buy,"黄牛").start();
        new Thread(buy,"他").start();
    }
}

class Buy implements Runnable{

    private int num = 10;
    boolean falg = true;

    @Override
    public void run() {
        while (falg)
        {

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

    }

    private synchronized void buy() throws InterruptedException {
        if(num <= 0)
        {
            falg = false;
            return;
        }

        System.out.println(Thread.currentThread().getName() + "拿到了第" + num-- + "张");


    }
}

7.死锁

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

package com.kuang.test;

import java.util.Date;

public class LockTest {
        public static String obj1 = "obj1";
        public static String obj2 = "obj2";
        public static void main(String[] args) {
            LockA la = new LockA();
            new Thread(la).start();
            LockB lb = new LockB();
            new Thread(lb).start();
        }
    }
    class LockA implements Runnable{
        public void run() {
            try {
                System.out.println(new Date().toString() + " LockA 开始执行");
                while(true){
                    synchronized (LockTest.obj1) {
                        System.out.println(new Date().toString() + " LockA 锁住 obj1");
                        Thread.sleep(3000); // 此处等待是给B能锁住机会
                        synchronized (LockTest.obj2) {
                            System.out.println(new Date().toString() + " LockA 锁住 obj2");
                            Thread.sleep(60 * 1000); // 为测试，占用了就不放
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    class LockB implements Runnable{
        public void run() {
            try {
                System.out.println(new Date().toString() + " LockB 开始执行");
                while(true){
                    synchronized (LockTest.obj2) {
                        System.out.println(new Date().toString() + " LockB 锁住 obj2");
                        Thread.sleep(3000); // 此处等待是给A能锁住机会
                        synchronized (LockTest.obj1) {
                            System.out.println(new Date().toString() + " LockB 锁住 obj1");
                            Thread.sleep(60 * 1000); // 为测试，占用了就不放
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

}

8.lock锁

package com.kuang.test;

import java.util.concurrent.locks.ReentrantLock;

public class locktwo {

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

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

}

class tickes implements Runnable{

    private int num = 10;

    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true)
        {
            lock.lock();
            if(num > 0)
            {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
                System.out.println(num--);
            }
            lock.unlock();
        }
    }
}

image-20220410214342580

 

 

posted @ 2022-04-10 21:47  爽爽子的秃头生活  阅读(121)  评论(0)    收藏  举报