Java SE（多线程）

最新推荐文章于 2024-07-19 17:37:28 发布

Taboy-Wllove

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量181

点赞数

分类专栏：自学学习文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_44351285/article/details/113099540

版权

自学同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

学习

10 篇文章 0 订阅

订阅专栏

多线程

多线程创建方式一：继承Thread类，重写run方法，调用start开启线程

package com.java.thread;

//创建线程方式一：继承Thread类，重写run方法，调用start开启线程
//线程开启不一定立即执行，由cpu调度执行
public class TestThread extends Thread{
    @Override
    public void run() {
        //run()方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习"+i);
        }

    }

    public static void main(String[] args) {
        //main()线程，主线程

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

        for (int i = 0; i < 1000; i++) {
            System.out.println("我在打篮球"+i);
        }
    }
}

方式一应用：使用多线程下载网络图片

//使用前请下载commoms.io的jar包,并把jar包导入到资源目录下
package com.java.thread;

//导入commons.io包
import org.apache.commons.io.FileUtils;

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

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() {
        WebDownload webDownload = new WebDownload();
        webDownload.download(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%2Fa0.att.hudong.com%2F52%2F62%2F31300542679117141195629117826.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1614047780&t=852ab4c2ec1d3c43ee685c7cf014bec6","t1.jpg");
        TestThread2 t2 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F52%2F62%2F31300542679117141195629117826.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1614047780&t=852ab4c2ec1d3c43ee685c7cf014bec6","t2.jpg");
        TestThread2 t3 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F52%2F62%2F31300542679117141195629117826.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1614047780&t=852ab4c2ec1d3c43ee685c7cf014bec6","t3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}
class WebDownload{
    public void download(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download方法出现异常！");
        }
    }
}

线程创建方式二：实现Runnable接口，使用静态代理方式开启线程

package com.java.thread;

//线程创建方式二：实现Runnable接口，使用静态代理方式开启线程
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) {
        TestThread3 testThread3=new TestThread3();
        //Thread thread=new Thread(testThread3);
        //thread.start();

        //静态代理
        new Thread(testThread3).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("我在打篮球"+i);
        }
    }
}

方式二应用：模拟抢票

package com.java.thread;

/*出现的问题：
* 多个人存在抢相同的票，不安全 */

//多线程实现抢票（基础实现）
public class TestThread4 implements Runnable{
    private int tictetNums=10;//票数


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

    }

    public static void main(String[] args) {

        TestThread4 ticket = new TestThread4();


        new Thread(ticket,"小明").start();
        new Thread(ticket,"小王").start();
        new Thread(ticket,"校长").start();
    }
}

方式二应用：龟兔赛跑

package com.java.thread;

//龟兔赛跑
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%20==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){//先到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();
    }
}

线程创建方式三：实现Callable类

package com.java.thread;

import jdk.jshell.spi.ExecutionControl;

import java.util.concurrent.*;

//线程创建方式三：实现Callable类
//可以定义返回值
//可以抛出异常
public class TestThread5 implements Callable<Boolean> {
    @Override
    public Boolean call() {

        System.out.println(Thread.currentThread().getName()+"在学习");

        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestThread5 t1 = new TestThread5();
        TestThread5 t2 = new TestThread5();
        TestThread5 t3 = new TestThread5();

        //创建执行服务
        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();

    }
}

扩展

静态代理

package com.java.thread;


/*静态代理模式
*1.代理对象和真实对象都需要实现同一个接口
*2.代理对象要代理真实对象*/


/*优点：
* 1.代理对象可以做真实对象做不了的事
* 2.真实对象可以专注做自己的事*/


public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.Marry();

        //对比Thread调用start方法
        //new WeddingCompany(new you()).Marry();
        //new Thread(new Runnable()).start();
    }
}

interface Marry{
    void Marry();
}


//真实角色
class You implements Marry{
    @Override
    public void Marry() {
        System.out.println("我要结婚了!");
    }
}

//代理角色
class WeddingCompany implements Marry{
    //代理目标角色
    private You target;

    public WeddingCompany(You target) {
        this.target = target;
    }

    @Override
    public void Marry() {
        before();//代理工作
        this.target.Marry();//真实对象
        ending();//代理工作
    }

    private void ending() {
        System.out.println("结婚后工作");
    }

    private void before() {
        System.out.println("结婚前准备");
    }
}

Lambda表达式

package com.java.thread;

/*推到Lambda表达式*/
public class TestLambda {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("Lambda2");
        }
    }

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

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

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("Lambda3");
            }
        }
        like=new Like3();
        like.Lambda();

        //5.匿名内部类,没有类的名称，只有借助接口或者父类
        like=new ILike() {
            @Override
            public void Lambda() {
                System.out.println("Lambda4");
            }
        };
        like.Lambda();

        //6.用Lambda简化
        like=()-> {
            System.out.println("Lambda5");
        };
        like.Lambda();
    }
}

//1.定义一个函数式接口
//任何接口只包含一个抽象方法
interface ILike{
    void Lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("Lambda1");
    }
}

Lambda简化

package com.java.thread;

public class TeatLambda2 {
    public static void main(String[] args) {
        Love love=null;//创建接口对象

        //1.Lambda表示简化
        love=(int a)->{
            System.out.println("Love"+a);
        };
        love.love(12);

        //简化1：参数简化
        love=(a)->{
            System.out.println("Love"+a);
        };
        love.love(23);

        //简化2：简化括号
        love=a->{
            System.out.println("Love"+a);
        };
        love.love(45);

        //简化3：简化花括号（仅限一行代码）
        love=a-> System.out.println("Love"+a);
        love.love(56);

        /*总结
        * 1.必须是函数式接口，即接口只有一个抽象方法
        * 2.多个参数情况下也可以去掉参数类型，但是必须加上括号
        * 3.不同参数类型也可以去掉*/
    }
}

interface Love{
    void love(int a);
}

Taboy-Wllove

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
5
评论
Java SE（多线程）

多线程多线程创建方式一：继承Thread类，重写run方法，调用start开启线程package com.java.thread;//创建线程方式一：继承Thread类，重写run方法，调用start开启线程//线程开启不一定立即执行，由cpu调度执行public class TestThread extends Thread{ @Override public void run() { //run()方法线程体 for (int i = 0; i
复制链接

扫一扫