java多线程

实现runnable的多线程怎么调试？

摘要：本篇文章主要讲解java多线程，包括线程，锁，各种并发问题等

0、Intro

0.1 进程与线程

program：程序（源码）

Process：进程：程序的一次执行过程，是系统资源分配的单位

Thread：线程：CPU调度和执行的单位

常见的基本线程：

main()：主线程——系统入口，用于执行整个程序

gc()：垃圾回收线程

这两个线程是所有进程不创建也会有的线程

注：

  • 只有多核CPU才是并行多线程，单核只能做到并发多线程

  • 在一个进程中，如果开辟了多个线程，线程的运行由操作系统安排，操作系统的先后顺序是不能人为干预的

  • 同一份资源会存在资源抢夺的问题，需要加入并发控制

  • 线程会带来额外的开销，如CPU调度时间，并发控制开销

  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

1、！线程实现

1.1 方法一、继承Thread类

1.1.1 步骤

  1. 自定义线程类继承Thread类

  2. 重写run()方法：所有线程需要做的事都放到run方法中

  3. 创建线程对象，调用start()方法启动线程

1.1.2 run与start

调用run方法并没创建线程，而是主线程转而去执行run方法而已

调用start才是创建了线程，start方法开启线程后不一定立即执行，而是和主线程并发，由OS调度

run

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
/**
 * 创建线程方法一：继承Thread类，重写run方法，调用start开启线程
 * 总结：线程开启不一定立即执行，由OS调度
 */
public class Index {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();
        ThreadC threadC = new ThreadC();

        threadA.start();
        threadB.start();
        threadC.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("main");
        }

    }
}

public class ThreadA extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("A");
        }
    }
}

注：一个类只能创建一个线程，要创建多个线程，就要创建多个类

注：Thread类也实现了runnable接口

1.2方法二、实现Runnable接口

1.2.1 步骤
  1. 定义线程类，实现Runnable接口
  2. 实现run方法，编写方法执行体
  3. 创建线程对象，创建Thread类的对象作为代理，通过代理的start方法启动线程
1
2
3
4
5
6
7
8
9
10
11
12
13
public class ThreadARunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("A");
        }
    }
}

public static void main(String[] args) {
    ThreadARunnable threadARunnable = new ThreadARunnable();
    new Thread(threadARunnable).start();
}
1.2.2 代理

Runnable方式相比于继承Thread方式，最主要的区别就是线程启动方面：

1
2
3
4
5
6
7
//ClassA extends Thread
ClassA a = new A();
a.start();

//ClassA implements Runnable
ClassA a = new A();
new Thread(a).start;

代理方式可以这么理解：

Runnable对象仅仅作为Thread对象的Target，Runnable实现类里面的run方法仅作为线程执行体，而实际的线程对象依然是Thread实例

值得注意的是，Runnable对象整体作为线程的target，所以多个线程既共享了Runnable对象的方法又共享了Runnable的变量

1.3 对比

继承法

  • 启动线程：start

实现法

  • 启动线程：传入目标对象+Thread对象.start
  • 推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

1.4 小实验：龟兔赛跑问题

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
42
43
44
45
46
47
48
package com.mars.javaThread.concurrent;

public class TRRace implements Runnable {
    //注意：只有Runnable的（实现类）级别的变量才能被多线程共享
    String winner = null;

    @Override
    public void run() {
        //方法级别的变量，每个线程各自拥有一套，互不影响
        int steps = 100;//每个角色距离终点还剩的距离
        while(steps>=0){//只要这个角色还没到终点，就继续跑；包含0是因为要把0传进判断方法才能宣告结束
            if(winner!=null) break;//如果已经有赢家了了，就结束（break）了

            //模拟兔子休息
            if(Thread.currentThread().getName().equals("兔子") && steps%50==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //没有gameover，往前跑
            if(Thread.currentThread().getName().equals("兔子"))
                steps-=5;
            else
                steps--;

            System.out.println(Thread.currentThread().getName() + "距离终点还剩 " + steps + " 步");
            gameover(steps);//检查一下有没有gameover
        }
    }

    public void gameover(int steps) {
        if (steps <= 0) {
            //将当前线程的名字打印出来
            winner = Thread.currentThread().getName();
            System.out.println("The winner is " + winner);
        }
    }

    public static void main(String[] args) {
        TRRace trRace = new TRRace();
        new Thread(trRace,"兔子").start();
        new Thread(trRace,"乌龟").start();

    }

}

1.5 方法三：实现Callable接口（了解）

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
public class ThreadACallable implements Callable<Object> {
    //1、实现接口，注意传递泛型与下面的call方法的返回类型相同
    
    @Override
    //2、重写call方法
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("hhh " + i + " ;");
        }
        return null;
    }

    public static void main(String[] args) throws Exception{
        //3、创建执行对象
        ThreadACallable threadACallable1 = new ThreadACallable();
        ThreadACallable threadACallable2 = new ThreadACallable();
        ThreadACallable threadACallable3 = new ThreadACallable();
        //4、创建执行服务 建池
        ExecutorService service = Executors.newFixedThreadPool(3);
        //5、提交执行
        Future<Object> r1 = service.submit(threadACallable1);
        Future<Object> r2 = service.submit(threadACallable2);
        Future<Object> r3 = service.submit(threadACallable3);

        //6、获取结果
        Object rs1 = r1.get();
        Object rs2 = r2.get();
        Object rs3 = r3.get();

        //7、关闭服务
        service.shutdown();
    }
}

1.6 静态代理模式（——Thread中的设计模式）

接口变量指向接口的实现对象，调用方法时调用的是实现对象的重写方法

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.mars.DesignPattern;
import com.mars.javaThread.Create.ThreadARunnable;
/**
 * 深究Thread类的静态代理模式
 */
public class ThreadAgencyModel {

    public static void main(String[] args) {
        /*
        You you = new You();
        WedingCompany wedingCompany = new WedingCompany(you);
        wedingCompany.happyMarry();
        */
        
        //You you = new You();
        //new WedingCompany(you).happyMarry();
        
        //以上例子就是一个完整的代理模式
        //构造线程的第二种方法，本质上也是代理模式，请看：
        
        ThreadARunnable threadARunnable = new ThreadARunnable();
        new Thread(threadARunnable).start();
        
        //比较一下，会发现完全相同
        //需要注意的是，代理模式只要求能完成代理功能即可，不用把方法都放在相同的方法名中，所以Thread对象不用公共方法run没问题
       
    }
}
interface Marry{
    void happyMarry();
}
//真实对象：专注核心业务
class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("Mars got married");
    }
}
//代理对象：帮助解决铺垫和首尾工作
class WedingCompany implements Marry{
    Marry target;
    public WedingCompany(Marry target) {
        this.target = target;
    }
    @Override
    public void happyMarry() {
        before();
        target.happyMarry();
        after();
    }
    public void before(){
        System.out.println("筹办婚礼");
    }
    public void after(){
        System.out.println("收款");
    }
}

静态代理模式总结：

1、真实对象和代理对象都要实现同一个接口

2、代理对象要代理真实角色（即必须把角色传给代理对象）

3、好处

  • 真实对象只需要专注于自己的核心工作
  • 其他前仆后继的工作由代理对象来完成即可

静态代理模式的简化写法：

1
new WedingCompany(new You()).happyMarry();

1.7 lamda表达式

1.7.1 介绍
1.7.2 逐步优化过程
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.mars.javaThread;

public class LambdaIntro {

    static class UseOnlyOnce1 implements  OneMethod{
        @Override
        public void oneMethod() {
            System.out.println("2、我是静态内部类，只能被用到一次");
        }
    }

    public static void main(String[] args) {
        OneMethod useOnlyOnce;
        //接口变量指向接口的实现类的实例
        //外部类
        useOnlyOnce = new UseOnlyOnce();
        useOnlyOnce.oneMethod();
        //静态内部类
        useOnlyOnce = new UseOnlyOnce1();
        useOnlyOnce.oneMethod();

        class UseOnlyOnce2 implements  OneMethod{
            @Override
            public void oneMethod() {
                System.out.println("3、我是局部内部类，只能被用到一次");
            }
        }
        //局部内部类
        useOnlyOnce = new UseOnlyOnce2();
        useOnlyOnce.oneMethod();
        
        //匿名内部类，必须借助接口或者父类（要不然你都不知道写啥方法）
        //一般匿名内部类就是用来实现接口或者重写父类的方法的
        //匿名内部类的结果就是一个实例，可以直接拿着用
        useOnlyOnce = new OneMethod() {
            @Override
            public void oneMethod() {
                System.out.println("4、我是匿名内部类，只能被用到一次");
            }
        };
        useOnlyOnce.oneMethod();

        //函数式编程：lambda表达式
        useOnlyOnce = ()->{
            System.out.println("4、我是匿名内部类，只能被用到一次");
        };
        //小括号是参数，大括号是方法体，可以这样理解：匿名内部类去掉接口（父类）名和方法名
        
        //点的这个方法，就是接口里面的方法，接口里只有一个方法名，实现类也只有一个方法，所以不需要保留类和方法名了
        useOnlyOnce.oneMethod();
        
    }
}

interface OneMethod{
    void oneMethod();
}

class UseOnlyOnce implements  OneMethod{
    @Override
    public void oneMethod() {
        System.out.println("1、我是外部类，我只能被用到一次");
    }
}

听到再次简化

2、线程状态

3、！线程同步

初始线程同步问题

看以下一段代码的执行结果：

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
public class TicketsIntro implements Runnable{
    private int tickets = 10;
    @Override
    public void run() {
        while(true){
            if(tickets<=0) break;
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
                System.out.println(Thread.currentThread().getName()+"拿到了第" + tickets-- + "张票");
        }
    }
}


public static void main(String[] args) {
    TicketsIntro ticketsIntro = new TicketsIntro();
    new Thread(ticketsIntro,"小明").start();
    new Thread(ticketsIntro,"老湿").start();
    new Thread(ticketsIntro,"黄牛").start();
}

/*
黄牛拿到了第9张票
小明拿到了第10张票
老湿拿到了第8张票
黄牛拿到了第7张票
小明拿到了第6张票
老湿拿到了第5张票
老湿拿到了第4张票
黄牛拿到了第3张票
小明拿到了第2张票
黄牛拿到了第1张票👈 
老湿拿到了第1张票👈
小明拿到了第0张票
*/

以上代码的运行结果，甚至出现了两个人拿同一张票的情况，这就是由于不加限制时进程并发访问资源造成的混乱情况。

因为只有一个进程，所以只有一套数据？？？

4、线程通信

5、Plus

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家