多线程详解

多线程详解

Thread类 Runnable接口 Callable接口

继承类，实现接口

1、Thread类

继承Thread类，重写run（）方法编写线程执行体，调用start开启线程

public class TestThread1 extends Thread{
	public void run(){
		for(int i = 0;i<20 ;i++){
		System.out.println("我在看代码。。。"+i);
		}
	}
	public static void mian(String[] args){
	//创建一个线程对象
	TestThread1 testThread1 = new TestThread();
	testThread.start();//start表示同时进行
	//run 表示进行某一特定的方法
	for(i=0;i<20;i++){
		System.out.println("我再学习多线程。。");
	}
	}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZlTEvy9I-1601259231522)(C:\Users\华为\AppData\Roaming\Typora\typora-user-images\image-20200817143945651.png)]

现成的开启不会立即执行，由cpu进行调度使用

多线程下载图片实例

创建多线程的步骤：
    1、创建实际方法
    2、使用多线程进行包装
    3、调用主函数方法
    
    
class WebDownloader{
    public void downloader(){
		FileUtils.copyURLToFile(new URL(url),new File(name));
    }
}
public class TestThread extends Thread{
    private String url;
    private String name;
    public TestThread(String url,String name){
        this.url=url;
        this.name=name;
    }
    public void run(){
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件为："+name);
    }
    public static void main(String[] args){
        TestThread t1 = new TestThread(url" ",ad.jpg);
        t1.start();
    }
}

2、Runnable 接口

实现接口步骤

1、定义MyRunnable类实现Runnable接口

2、实现run（）方法，编写线程执行体

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

public class TestThread3 implements Runnable{
    public void run(){
        for(int i=0;i<200;i++){
            System.out.println("我在看代码--"+i);        
        }
    }
    public static void mian(String[] args){
        TestThread3 testThread3 = new TestThread3();
        for(int i=0;i<1000;i++){
            System.out.print("我在学习多线程--");
        
        }
    }
}

Thread与Runnable

Thread 是类的形式，子类与其关系强调为继承，Runnable是以接口的形式让实现对象方法拥有接口方法。在Java中更加倾向于使用接口的方法

排队买票的实例

public class TestThread4 implenments Runnable{
    private int ticketNums= 10;
    public void run(){
        System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNames--+"票");
    }
    public static void main(String[] args){
        TestThread4 ticket = new TestThread4();
        new Thread(ticket,name:"小明").start();
        new Thread(ticket,name:"老师").start();
        new Thread(ticket,name:"").start();
    }
}

例子龟兔赛跑

public class Race implements Runnable{
    private static String winner;
    public void run{
        for(int i=0;i<100;i++){
            if(Thread.currentThread().getName().equals("兔子")&&i%10=0){
                try{
                    Thread.sleep(millis:200);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
    		boolean flag = gameOver(i);
            if(flag){
                break;
            }
            System.out.print(Thread.currentThread().getName()+"-->跑了"+i+步);
            
    }
    public boolean gameOver(int steps){
        if(winnwe!=null){
            return true;
        }else{
            if(steps=100){
                winner = Thread.currentThread().getNmae();
                System.out.println("winner is "+winner);
                return true;
            }
        }
    }
    public static void mian(String[] args){
        Race race = new Race();
        new Thread(race,name:"兔子").start();
        new Thread(race,name:"乌龟").start();
    } 
        
}

对于变量的使用，检测引用变量是否相等用equals

，而等于号相当于进行地址的比较

if（Thread.currentThread().getName().equals(“兔子”)）

3、Callable 接口

1、实现Callable接口，需要返回值类型

2、重写call方法，需要抛出异常

3、创建目标对象

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

5、提交执行 Future result1 = ser.submit()

6、关闭服务：ser.shutdownNow()

public class TestCallable implement Callable<>{
    private String url;
    private String name;
    
    public TestCallable(String url,String name){
        this.url=url;
        this.name=name;
    }
    //创建执行服务
    ExecutorService ser = Executors.newFixedThreadPool(nThreads: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();   
}

4、静态代理模式

真实对象和代理对象都要实现同一个接口，代理对象要代理真实角色

使用一个对象来选择利用代理的思想性质来进行。

5、Lamda 表达式

简化代码量

函数式接口 任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口。对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

public class TestLambda1{
//第二种静态内部类
    static class Like2 implements ILike{
        public void lambda(){
            System.out.println("I Like lambda2");
        }
    }

    
	public static void main(String[] args){
	ILike like = new Like();
	like.lambda();
	
    like2 = new Like2();
    like2.lambda();
     //第三种   局部内部类
        class like3 implements ILike{
            public void lambda(){
                System.out.println("i like lambda");
            }
        }
     like3= new Like3();
     like3.lambda();
    //第四种匿名内部类
     like4 = new ILike(){
         public void lambda(){
             System.out.println("I like fhh");
         }
     }
    //第五种Lambda简化
    like = ()->{
        System.out.println("i like lambda");
    }
    like.lambda();
        
        
lambda 表达式只能有一行代码的情况下才能简化成一行，如果有多行，那么
         
    }
}


interface ILike{
	void lambda();
}
//第一种实现方式
class Like implements ILike{
	public void lambda(){
		System.out.println("I like lambda");
	} 
}

1、创建接口

2、实现外部类/实现静态内部类/实现局部内部类/匿名内部类/lambda表达式类