欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  科技

并发编程系列

程序员文章站 2022-04-07 18:23:56
线程和进程的概念:  线程是CPU执行的基本单位,是进程运行的独立单元。  进程是操作系统执行的基本单位,每个线程都是每个进程的一次执行,每个进程中可以有多个线程,每个进程都会有一个独立的内存空间。举一个例子说明一下进程和线程:QQ和人聊天和人视屏就是一个进程和两个线程。进程和线程的区别:进程:有独立的内存空间,堆栈内存空间是独立的,每个进程必须有一个线程。线程:栈内存空间共享(堆内存空间共享),线程消耗资源小。创建多线程:一共四种方式:给个图更能理解多线程的关系:实现线程第一种方式继...

线程和进程的概念
  线程是CPU执行的基本单位,是进程运行的独立单元。
  进程是操作系统执行的基本单位,每个线程都是每个进程的一次执行,每个进程中可以有多个线程,每个进程都会有一个独立的内存空间。
举一个例子说明一下进程和线程:QQ和人聊天和人视屏就是一个进程和两个线程。
进程和线程的区别:
进程:有独立的内存空间,堆栈内存空间是独立的,每个进程必须有一个线程。
线程:栈内存空间共享(堆内存空间共享),线程消耗资源小。
创建多线程:
一共四种方式:
给个图更能理解多线程的关系:
并发编程系列
实现线程第一种方式继承Thread类:

public class Demo1Thread extends Thread{
@Override
public void run() {
    System.out.println("继承Thread,实现多线程");
}

public static void main(String[] args) {
    Demo1Thread thread = new Demo1Thread();

    thread.start();//开启线程,这里的开始线程不一定就执行了,只是等待被CPU调度


}

}
实现线程的第二种方法实现Runnable接口:

public class Demo2Runnable implements Runnable{

    @Override
    public void run() {
        System.out.println("实现Runnable接口实现多线程");
    }

    public static void main(String[] args) {
        Demo2Runnable runnable = new Demo2Runnable();
        Thread thread = new Thread(runnable);

        thread.start();

    }
}
匿名内部类实现:
public class Demo2Runnable{


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类实现Runnable接口,实现多线程");
            }
        }).start();


    }
}

实现线程的第三种方法实现Callable接口实现多线程:(和第二种方式的区别就是实现callable有返回值,而实现runnable没有返回值)

public class Demo3Callable implements Callable {

    @Override
    public String call() throws Exception {
        return "我是callable方法实现的多线程";
    }

    public static void main(String[] args) throws Exception {
        Demo3Callable callable = new Demo3Callable();
        FutureTask<String> target = new FutureTask<String>(callable);
        new Thread(target).start();
        
        //这个是直接这个类获取的值
        String call = callable.call();
        
        //futureTask获取执行的值
        String s = target.get();
        System.out.println(call);
        System.out.println(s+"------");

    }
}

第四中方式线程池实现多线程:

public class ThreedPoolDemo implements Runnable{

    @Override
    public void run() {
        System.out.println("我是实现runnable接口然后使用线程池实现多线程");
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        FutureTask<String> task = new FutureTask<>(new ThreadDemo());
        //executorService.execute(new ThreedPoolDemo());
        try {
            executorService.execute(task);
            String s = task.get();
            System.out.println(s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();

    }
    static class ThreadDemo implements Callable<String>{
        @Override
        public String call() throws Exception {
            return "我是首先实现Callable方法的多线程";
        }
    }
}

  其实把上面的图记住就很能明白,四种线程的实现方式。

本文地址:https://blog.csdn.net/qq_43169491/article/details/110099742

相关标签: Java并发编程