多线程之初识线程

创建线程

要了解多线程，肯定要先知道如何创建线程，创建线程的方式有三种，继承 Thread 类、实现 Runnable 接口、实现 Callable 接口。

//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
public class TestThread1 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线程，主线程

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

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

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码");
        }
    }

    public static void main(String[] args) {

        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread3);

        thread.start();

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

第三种通过一个下载的jar包来演示，先导入依赖

<dependencies>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>
</dependencies>

//线程创建方式三；实现Callable接口
//先导入一个依赖
/*
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;
    }

    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("图片地址", "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);

        //获取结果
        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("I0异常, downloader方法出现问题");
        }
    }

}

线程不安全

死锁条件

• 互斥条件: 一个资源每次只能被一个进程使用。
• 请求与保持条件: 一个进程因请求资源而阻塞时，对已获得的资源保持不放。
• 不剥夺条件 :进程已获得的资源，在末使用完之前，不能强行剥夺。
• 循环等待条件 :若干进程之间形成一种头尾相接的循环等待资源关系。

本作品采用《CC 协议》，转载必须注明作者和本文链接