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

线程创建

时间：2022-11-12 13:45:52浏览次数：52  
标签：创建 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

相关文章

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99