process&Thread

process 进程

进程是执行程序的一次执行过程
一个进程包含多个线程

Thread 线程

  • main是主线程，系统的入口
  • 线程是独立的执行路径
  • 对于同一份资源，会存在资源抢夺，需要加入并发控制
  • 线程的运行由cpu来调度

线程创建

三种方式:

  • Thread class -> extends Thread
  • Runnable interface -> implements Runnable
  • Callable interface -> implements Callable

继承Thread类

步骤:继承Thread类，重写run()方法,调用start()方法开启线程

线程开启不一定立即执行，由cpu调度决定
start()开启线程后，主线程和其他线程交替执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Thread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("这是run线程" + i);
        }
    }

    public static void main(String[] args) {
        //主线程
        //创建一个线程对象
        Thread1 thread1 = new Thread1();
        //start:主线程和run线程交替
        thread1.start();
        //run:先run后主 一条线程
        //thread1.run();

        for (int i = 0; i < 20; i++) {
            System.out.println("这是主线程" + i);
        }
    }
}

实现Runnable接口

实现Runnable接口，重写run()方法，执行线程需要丢入runnable接口实现类，调用start()开启线程
可以用lambda表达式，表示run方法

1
2
3
4
5
6
7
8
9
10
11
public class Thread3 implements Runnable{
    @Override
    public void run() {
        System.out.println("11111111111111");
    }

    public static void main(String[] args) {
        Thread3 thread3 = new Thread3();
        new Thread(thread3).start();
    }
}

并发问题

多个线程同时操作同一个对象，线程不安全，数据紊乱


Callable接口

  • 实现Callable接口，需要返回值类型
  • 重写call方法，需要抛出异常
  • 创建目标对象
  • 创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(10);
  • 提交执行 Future<Boolean> result1 = ser.submit(t1);
  • 获取结果 boolean r1 = result1.get();
  • 关闭服务 ser.shutdownNow();

静态代理

  • 真实对象要和代理对象实现同一个接口
  • 代理对象要代理真实角色
  • 代理对象可以做很多真实对象不能做的事情
  • 真实对象专注做自己的事情

Lambda表达式

1
new Thread(() -> {})

函数式接口: 只包含一个抽象方法的接口，称为函数式接口

  • lambda表达式只有一行的时候才可简化为一行
  • 前提是接口为函数式接口
  • 多个参数也可以去掉参数类型，需加(),要去都去
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//匿名内部类 ->lambda表达式
public class TestLambda {
    public static void main(String[] args) {
        // 匿名内部类
        doHomework doHomework = new doHomework() {
            @Override
            public void help(String name) {
                System.out.println("help "+ name);
            }
        };
        doHomework.help("me");

        //lambda表达式
        lambda lambda = (int a)-> {
                System.out.println("this is test" + a);
            };
            lambda.test(2);

        //简化1 去掉参数类型
        lambda = (a) -> {
            System.out.println("this is test" + a);
        };
        
        //简化2 
        lambda = a -> {
            System.out.println("this is test" + a);
        };
        
        //简化3
        lambda = a -> System.out.println("this is test" + a);
    }

}

interface doHomework {
    void help(String name);
}

interface lambda {
    void test(int a);
}