Java线程

最新推荐文章于 2024-05-01 09:15:00 发布

星域_03zhan

最新推荐文章于 2024-05-01 09:15:00 发布

阅读量642

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_45968950/article/details/124462802

版权

Java 专栏收录该内容

42 篇文章 3 订阅

订阅专栏

线程简介：

1.多任务：同一时间给多个程序运行处理数据

2.多线程：从软件或硬件上实现多个线程并发执行的技术

3.进程：执行程序的一次执行过程，一个进程可以有多个线程，是系统资源分配的单位

4.线程：线程是CPU调度和执行的单位，比如main线程,垃圾处理线程

核心概念：

1、线程就是独立的执行路径；

2、在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程、gc线程;

3、main()称为主线程，为系统的入口，用于执行整个程序；

4、在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序是不能人为干预的；

5、对同一份资源操作时，会存在资源抢夺的问题，需要加以并发控制；

6、线程会带来额外的开销，如cpu调度时间，并发控制开销；

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

线程的创建方式：

1.继承Thread类

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

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

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

public class TestThread1 extends Thread {
    //重写run方法
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("我在数---"+i);
        }
    }
    public static void main(String[] args) {

        //创建一个线程对象
        TestThread1 testThread1=new TestThread1();
        //调用start方法开启线程
        testThread1.start();

        for(int i=0;i<20;i++){
            System.out.println("我在学习---"+i);
        }
    }
}

线程创建不一定立刻执行，由CPU调度执行。

练习：实现多线程同步下载图片

public class TestThread2 extends Thread {
    private  String  url;
    private  String  name;

    public TestThread2(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public void run() {
        WebDownLoader webDownLoader=new WebDownLoader();
        webDownLoader.downLoader(url,name);
        System.out.println("下载了文件名为："+name);
    }

    public static void main(String[] args) {
        TestThread2 t1=new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg9.51tietu.net%2Fpic%2F2019-091317%2Flmy2tfo3cdzlmy2tfo3cdz.jpg&refer=http%3A%2F%2Fimg9.51tietu.net&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650894745&t=d23c9187c059f9cf1af043575efb8e21","3.271");
        TestThread2 t2=new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201902%2F10%2F20190210150318_mblfe.jpg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650961582&t=258e9e5bb20cc5f618d392037556cbf1","3.272");
        TestThread2 t3=new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg1.doubanio.com%2Fview%2Fnote%2Fl%2Fpublic%2Fp82460877.jpg&refer=http%3A%2F%2Fimg1.doubanio.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650961633&t=243c23fdb1bbdb1f0b0d98cfee8e9a32","3.273");
        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方法出问题");
        }

    }
}

不建议使用：避免OOP单继承局限性

2.实现Runnable接口

(1)创建一个线程实现Runnable接口

(2)实现run方法

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

public class TestThread3 implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("我在数---"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3=new TestThread3();
        //创建线程对象，通过线程对象来开启线程，代理
        Thread thread=new Thread(testThread3);
        thread.start();
//        new Thread(testThread3).start; 等同于上面的那两句

        for(int i=0;i<20;i++){
            System.out.println("我在学习---"+i);
        }
    }
}

推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。

 /**
     * 多个线程同时操作一个对象:买火车票的例子
     * 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
     * */

public class TestThread4 implements Runnable {
    //票数
    private int ticketNums=10;

    @Override
    public void run() {
        while(true){
            if(ticketNums <=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"票");

        }

    }

    public static void main(String[] args) {
        TestThread4 ticket=new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小花").start();
        new Thread(ticket,"小白").start();
    }
}

龟兔赛跑案例：

//模拟龟兔赛跑
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("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException 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 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）创建执行服务

（5）提交执行

（6）获取结果

（7）关闭服务

//callable的好处
    // 1.可以定义返回值 2.可以抛出异常

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://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg9.51tietu.net%2Fpic%2F2019-091317%2Flmy2tfo3cdzlmy2tfo3cdz.jpg&refer=http%3A%2F%2Fimg9.51tietu.net&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650894745&t=d23c9187c059f9cf1af043575efb8e21","3.2711");
        TestCallable t2=new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201902%2F10%2F20190210150318_mblfe.jpg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650961582&t=258e9e5bb20cc5f618d392037556cbf1","3.2721");
        TestCallable t3=new TestCallable("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg1.doubanio.com%2Fview%2Fnote%2Fl%2Fpublic%2Fp82460877.jpg&refer=http%3A%2F%2Fimg1.doubanio.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1650961633&t=243c23fdb1bbdb1f0b0d98cfee8e9a32","3.2731");
        //创建执行服务
        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();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        //关闭服务
        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方法出问题");
        }

    }
}

静态代理方式：

/**
 *静态代理模式：
 * 真实对象和代理对象都要实现同一个接口
 * 代理对象要代理真实角色
 *
 * 好处：
 *  代理对象可以做很多真实对象做不了的事情
 *  真实对象专注做自己的事情
 * */

public class StaticProxy {
    public static void main(String[] args) {
        You you =new You();//你要结婚
        new Thread(()-> System.out.println("love")).start();
        new WeddingCompany(new You()).HappyMarry();
        
    }

}
interface Marry {
    void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry {

    @Override
    public void HappyMarry() {
        System.out.println("你要结婚啦~");
    }
}
//代理角色，帮助你结婚
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 after() {
        System.out.println("结婚之后，收钱");
    }
    private void before(){

        System.out.println("结婚之前，布置现场");

    }
}

线程状态：

在这里插入图片描述

1.线程停止：

/**
 * 测试stop
 * 1.建议线程正常停止----> 利用次数，不建议死循环
 * 2.建议使用标志位----> 设置一个标志位
 * 3.不要使用stop或者destroy 等过时或者jdk不建议使用的方法
 *
 * */
public class TestStop implements Runnable {
    //设置一个标志位
    private boolean flag=true;

    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("run...Thread"+i++);
        }
    }
    //2.设置一个公共的方法停止线程，转换标志位
    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<1000;i++){
            System.out.println("main"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

2.线程休眠-sleep

sleep(时间)指定当前线程阻塞的毫秒数

sleep存在异常InterruptedException

sleep时间达到后线程进入就绪状态

sleep可以模拟网络延时，倒计时等

每一个对象都有一个锁，sleep不会释放锁

（1）模拟网络延时：

//模拟网络延时
public class TestSleep implements  Runnable{
    //票数
    private int ticketNums=10;

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

        }

    }
    public static void main(String[] args) {
        TestSleep ticket=new TestSleep();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"小花").start();
        new Thread(ticket,"小白").start();
    }
}

网络延时暴露了多线程不安全的问题。

（2）模拟倒计时：

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

(3)打印当前系统时间并且自动更新时间

public class TestSleep2 {
   public static void main(String[] args) {
        //打印当前系统时间
        Date startTime=new Date(System.currentTimeMillis());//获取系统当前时间
        while(true){
            try {
                Thread.sleep(1000);//每休眠1000毫秒（一秒钟）执行
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime =new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.线程礼让-yield

让正在执行的线程暂停，但不堵塞；

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

让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()+"线程停止执行");
    }
}

4.线程的强制执行-join

5.观测线程状态

在这里插入图片描述

public class TestState {
    public static void main(String[] args) {
        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){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=thread.getState();
            System.out.println(state);
        }
    }
}

线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度按照优先级决定应该调度哪个线程来执行。

线程优先级最高也不一定先执行，只是先执行的概率大。

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);
        Thread t5=new Thread(myPriority);

        t1.start();
        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        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());
    }
}

守护线程：

线程分为用户线程和守护线程；虚拟机必须确保用户线程执行完毕；虚拟机不用等待守护线程执行完毕，如gc。

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---");
    }
}

线程同步：

多个线程操作同一个资源。

并发：同一个对象被多个线程同时操作。eg:两个人同时去两个银行取同一卡上的钱。

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

为了保证数据在方法中被访问的正确性，在访问时加入锁机制，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。

线程不安全的例子：

//不安全的买票，线程不安全，会出现负数
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station=new BuyTicket();
        new Thread(station,"倒霉孩子me").start();
        new Thread(station,"黄牛").start();
        new Thread(station,"厉害的别人").start();
    }
}
class BuyTicket implements Runnable{

    //票
    private int ticketNums=10;
    Boolean flag=true;//外部停止方式
    @Override
    public void run() {
    //买票
        while(flag){
            buy();
        }
    }
    private void buy(){
        //判断是否有票
        if(ticketNums<=0){
            return;
        }
        //模拟延时
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

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

线程不安全的集合：

ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。（线程不安全是指：当多个线程访问同一个集合或Map时，如果有超过一个线程修改了ArrayList集合，则程序必须手动保证该集合的同步性。）

线程安全的集合：

Vector、HashTable、Properties等集合类效率比较低但都是线程安全的。包java.util.concurrent下包含了大量线程安全的集合类，效率上有较大提升。

同步方法：

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

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

同步方法的弊端：方法里需要修改的内容才需要锁，锁的太多，浪费资源。

同步块：

synchronized（Obj)

Obj称为同步监视器；

1.Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

2.同步方法中无需同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者是class(反射)

在这里插入图片描述

死锁：

多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生死锁的问题。

造成死锁的例子：

//死锁：多个线程互相拥抱着对方需要的资源，然后形成死锁
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1=new Makeup(0,"小明");
        Makeup g2=new Makeup(1,"小红");
    g1.start();
    g2.start();
    }
}
//口红
class Lipstick{

}
//镜子
class Mirror{

}
class Makeup extends Thread{
    //需要的资源只有一份，用staic来保证只有一份
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();

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

    @Override
    public void run() {
        //化妆
        makeUp();
    }

    private void makeUp(){
        if(choice ==0){
            synchronized (lipstick){ //获得口红的锁
                System.out.println(this.name+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){ //一秒钟后想获得镜子
                    System.out.println(this.name+"获得镜子的锁");
                }

            }

        }else{
            synchronized (mirror){ //一秒钟后想获得镜子
                System.out.println(this.name+"获得镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick){ //一秒钟后想获得口红
                    System.out.println(this.name+"获得口红的锁");

                }
            }


        }

   }
}

把代码块拿到外面就不会造成死锁了：
在这里插入图片描述
产生死锁的四个必要条件：

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

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

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

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

这四个必要条件，只要想办法破坏其中的一个或多个条件就可以避免死锁的发生

Lock(锁)：

从jdk1.5开始，java提供了更强大的线程同步机制----通过显示定义同步锁对象来实现同步，同步锁使用lock对象充当。

Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对lock对象加锁，线程开始访问共享资源之前应先获得lock对象。

ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock（可重复锁）,可以显示加锁、释放锁。

//测试lock锁
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 ticketNums=10;
    //定义Lock锁
   private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try {
                lock.lock();//加锁
                if(ticketNums>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

synchronized与Lock的对比：

1.Lock是显式锁（手动开启和关闭锁，要记得关闭锁），synchronized是隐式锁，出了作用域自动释放

2.Lock只有代码块锁，synchronized有代码块锁和方法锁

3.使用Lock锁，JVM将花费较少的时间来调度线程。，性能更好。并且具有更好的扩展性（提供更多的子类）

4.优先使用顺序：

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

线程协作：

生产者消费者问题

星域_03zhan

关注

0
点赞
踩
0

收藏

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

文章目录线程简介：核心概念：线程的创建方式：1.继承Thread类2.实现Runnable接口3.实现Callable接口(了解)静态代理方式：线程状态：1.线程停止：2.线程休眠-sleep3.线程礼让-yield4.线程的强制执行-join5.观测线程状态线程优先级守护线程：线程同步：死锁：Lock(锁)：线程协作：线程简介：1.多任务：同一时间给多个程序运行处理数据2.多线程：从软件或硬件上实现多个线程并发执行的技术3.进程：执行程序的一次执行过程，一个进程可以有多个线程，是系统资源分配的单位
复制链接

扫一扫