首页 > 其他分享 >线程创建

线程创建

时间:2022-11-12 13:45:52浏览次数:60  
标签:创建 void System 线程 println new public

线程创建

继承Thread类

方法

1.自定义线程继承Thread类

2.重写run()方法,编写 线程执行体

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

注意:线程不一定立即执行,CPU安排调度

package come.demg.demo01;
//创建线程方法一:继承Thread类,重写run()方法,调用start开启线程
//线程不一定立即执行,CPU安排调度
public class TestThread01 extends Thread{
    @Override
    public void run() {
    //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码"+i);
        }
    }
    public static void main(String[] args) {
    //main线程,主线程
    //创建一个线程对象
        TestThread01 testThread01 = new TestThread01();
        
    //调用start()方法开启线程
        testThread01.start();
        
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线层"+i);

        }
    }
}

例题:多图下载

注意:commons-io官网:Commons IO – Commons IO Overview
commons-io-2.11.0.jar复制粘贴到新建文件包中

package come.demg.demo01;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多图下载
public class TestThread02 extends Thread{
    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestThread02(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) {
       TestThread02 t1 = new TestThread02("图片地址","1.jpg") ;
       TestThread02 t2 = new TestThread02("图片地址","2.jpg") ;
       TestThread02 t3 = new TestThread02("图片地址","3.jpg") ;
       //,调用start()方法,开启线程。(多线程运行中,CPU安排调度,下载并不是按顺序下载)
       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接口

方法

1.定义一个MyRunnable类实现Runnable接口

2.实现run()方法,编写线程执行体

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

package come.demg.demo01;
public class TestRunnable01 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码"+i);
        }
    }
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestRunnable01 testRunnable01 = new TestRunnable01();
        //创建线程对象,通过线程对象来开启我们的线程
        // Thread thread = new Thread(testRunnable01);
        //thread.start();
        new Thread(testRunnable01).start();


        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线层"+i);

        }
    }
}

小结

继承Thread类

​ 子类继承Thread类具备多线程能力

​ 启动线程: 子类对象.start()

实现Runable接口*(推荐使用)

​ 实现接口Runnable具有多线程能力

​ 启动线程:传入目标对象+Thread对象.start()

例题:龟兔赛跑

package come.demg;

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(10);
            }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 true;
            }
        }
        return false;
    }

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

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }

}

实现Callable接口

方法

  1. 实现Callable接口,需要返回值

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

  3. 创建目标对象

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

  5. 提交执行 Future r1 = ser.submit(t1);

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

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

    callable的好处

    1.可以定义返回值

    2.可以抛出异常

    例题:用Callable接口实现多图下载

    package come.demg.demo02;
    import org.apache.commons.io.FileUtils;
    import java.io.File;
    import java.io.IOException;
    import java.net.URL;
    import java.util.concurrent.*;
    
    //线程创建方式三:实现Callable接口
    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() {
            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("图片地址","1.jpg") ;
            TestCallable t2 = new TestCallable("图片地址","2.jpg") ;
            TestCallable t3 = new TestCallable("图片地址","3.jpg") ;
    
            //创建执行服务
            ExecutorService ser = Executors.newFixedThreadPool(3);
    
            //提交执行
            Future<Boolean> r1 = ser.submit(t1);
            Future<Boolean> r2 = ser.submit(t2);
            Future<Boolean> r3 = ser.submit(t3);
            
            System.out.println(rs1);
            System.out.println(rs2);
            System.out.println(rs3);
    
            //获取结果
            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 come.demg.proxysatic;
    //静态代理模式总结:
    /*
    真实对象和代理对象都要实现同一个接口
    代理对象要代理真实角色
    好处:
    代理对象可以做很多真实对象做不了的事
    真实对象专注做自己的事情
     */
    
    public class StacticProxy {
        public static void main(String[] args) {
            You you =new You();//你要结婚
    
          new Thread( ()-> System.out.println("我爱你") ).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("之前,布置现场");
        }
    }
    

Lambda表达式

好处

避免匿名内部类定义过多

可以让你的代码看起来很简洁

去掉了一些没有意义的代码,只留下核心逻辑

其实质属于函数式编程概念

函数式接口是学习lambda表达式的关键所在

函数式接口定义:

任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口

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

对于函数式接口,我们可以通过lambda表达式来创建该接口的对象

例题:lambda表达式推导过程

package come.demg.lambda;
//lambda表达式推导过程
public class TestLambda01 {

    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like 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("i like lambda3");
            }
        }
        like =new Like3();
         like.lambda();


         //5.匿名内部类
        like =new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();


        //6.用lambda简化
        like = () -> {
            System.out.println("i like lambda5");
         };
        like.lambda();
    }

}

//1.定义一个函数式接口
interface ILike{
    void lambda();
}

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

例题2:

package come.demg.lambda;

public class TestLambda02 {

    public static void main(String[] args) {
       ILove love =(a,b,c)-> {
               System.out.println("i love you-->"+a);
      };
       /*
       总结:
       1.lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹
       2.前提是接口为函数式接口
       3.多个参数也可以去掉参数类型,要去掉都去掉,必须加上括号
        */
       love.love(2,3,4);
    }
}
    //定义一个函数式接口
    interface ILove{
        void love(int a,int b,int c);
    }

总结:

1.lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹

2.前提是接口为函数式接口

3.多个参数也可以去掉参数类型,要去掉都去掉,必须加上括号

标签:创建,void,System,线程,println,new,public
From: https://www.cnblogs.com/SXDMG/p/16865970.html

相关文章