Fork me on GitHub

java-多线程

字数统计: 2.8k字   |   阅读时长≈ 11分

link方式（自定义方式）：

为什么ConcurrentHashMap的读操作不需要加锁？
ArrayList集合为什么不能使用foreach增加、删除、修改元素
堆和栈的区别

java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上是执行一段程序流即一段顺序执行的代码。java使用线程执行体来代表这段程序流。
java中通过继承Thread类来创建并启动多线程的步骤如下：
l 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。
2 创建Thread子类的实例，即创建了线程对象
3 调用线程对象的star()方法来启动该线程 

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
测试类
public class Demo01(){
    public static void main(String[] args){
        //创建自定义线程对象
        MyThread mt=new MyThread("新的线程");
        //开启新线程
        mt.start();
        //在主方法中执行for循环
        for(int i=0;i<10;i++){
            System.out.println("mian线程！"+1);
        }

    }
}
创建MyThread类
public class MyThread extends Thread{
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("线程");
        }
    }


}

构造方法：
public Thread() :分配一一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target, String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

创建线程的另一种方法是声明实现 Runnable接口的类，该类然后实现run方法。然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。
实现Runnable接口
java.lang.Runnable
Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run()的无参数方法。 

1
2
3
4
5
6
7
8
9
10
11
12
class PrimeRun implements Runnable{
    long minPrime;
    PrimeRun(long minPrime){
        this.minPrime=minPrime;
    }
    public void run(){

    }
}
创建并启动线程
PrimeRun p=new PrimeRun(100);
new Thread(p).start();
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
1 创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //2 在实现类中重写Runnable接口的run()方法，设置线程任务
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

public class Demo01Runnable{
    public static void main(String[] args){
        //3 创建一个Runnable接口的实现类对象
        RunnableImpl r=new RunnableImpl();
        //4 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t=new Thread(r);
        //5 调用Thread类中的start()方法，开启新的线程执行run()方法
        t.start();

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

Thread和Runnable的区别
如果一个类继承Thread ,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。
总结:
实现Runnable接口比继承Thread类所具有的优势:
1.适合多个相同的程序代码的线程去共享同一个资源。
2.可以避免java中的单继承的局限性。
3.增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
4.线程池只能放入实现Runable或Callable类线程,不能直接放入继承Thread的类。
扩充:在java中,每次程序运行至少启动2个线程。一个是main线程 ,一个是垃圾收集线程。因为每当使用
java命令执行个类的时候,实际上都会启动一个JVM ,每一个JVM其实在就是在操作系统中启动了一个进
程。
实现RunnabLe接口创建多线程程序的好处:
1.避免了单继承的局限性
一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
实现了Runnable接口，还可以继承其他的类,实现其他的接口
2.增强了程序的扩展性,降低了程序的耦合性(解耦)
实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)
实现类中，重写了run方法:用来设置线程任务
创建Thread类对象,调用start方法:用来开启新线程

匿名内部类方式实现线程的创建
匿名:没有名字
内部类:写在其他类内部的类
匿名内部类作用:简化代码
把子类继承父类,重写父类的方法，创建子类对象合-步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成-步完成
匿名内部类的最终产物:子类实现类对象,而这个类没有名字
格式:
new
父类/接口(){
重复父类/接口中的方法
};

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
public class InnerClassThread{
    public static void main(String[] args){
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            //重新run方法，设置线程任务
            @Override
            public void run(){
                for(int i=0;i<10;i++){
                    System.out.println("Thread.currentThread().getName()+"-->"+"霓虹");
                }
            }
        }.start();
        //线程的接口Runnable
        //Runnable r=new Runnable(){
            //重写run()方法，设置线程任务
            @Override
            public void run(){
                for(int i=0;i<10;i++){
                    System.out.println("Thread.currentThread().getName()+"-->"+"程序猿");
            }
        };
        new Thread(r).start();
    }
}
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
//包子类
public class BaoZi{
    //皮
    String pi;
    //馅
    String xian;
    //包子状态，有true，没有false,设置初始值为false没有包子
    boolean flag=false; 
}

/*
注意：
     包子铺线程和包子线程关系-->tongxin(互斥)
     必须同时同步技术保证两个线程只有一个在执行
     锁对象必须保证唯一，可以使用包子对象作为锁对象
     包子铺类和吃货类就需要把包子对象作为参数传递进来
       1.需要在成员位置创建一个包子变量
       2.使用带参数的构造方法，为这个包子变量赋值
*/
//包子铺类
public class BaoZiPu extends Thread{
    //创建一个包子变量
    private BaoZi bz;
    //使用带参数构造方法，为这个包子变量赋值
    public BaoZiPu(BaoZi bz){
        this.bz=bz;
    }
    //设置线程任务(run)：生产包子
    @Override
    public void run(){
        //定义一个变量
        int count=0;
        //让包子铺一直生产包子
        while(true){              
        //必须同时同步技术保证两个线程只有一个在执行
        synchronized(bz){
            //对包子状态进行判断
            if(bz.flag==true){
                //包子铺调用wait()方法进入等待状态
                try{
                    bz.wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            //被唤醒之后执行，包子铺生成包子
            if(count%2==0){
                //生产 薄皮 三鲜馅包子
                bz.pi="薄皮";
                bz.xian="三鲜馅";
            }else{
                //生产 冰皮 牛肉大葱馅
                bz.pi="冰皮";
                bz.xian="牛肉大葱馅";          
            }
            count++;
            System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
            //生产包子需要3秒
            try{
                Thread.sleep(millis:3000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            //包子铺生产好了包子，修改包子的状态为true有
            bz.flag=true;
            //唤醒吃货线程，让吃货线程吃包子
            bz.notify();
            System.out.println("包子已经生产好了："+bz.pi+bz.xain+"包子，吃货可以开始吃了");
        }
        }
    }
}
//吃货类
public class ChiHuo extends Thread{
    //创建一个包子变量
    private BaoZi bz;
    //使用带参数构造方法，为这个包子变量赋值
    public ChiHuo(BaoZi bz){
        this.bz=bz;
    }
    //设置线程任务(run):吃包子
    @Override
    public void run(){
        //使用死循环，让吃货一直吃包子
        while(true){
         //必须同时同步技术保证两个线程只有一个在执行
        synchronized(bz){
            //对包子状态进行判断
            if(bz.flag==false){
                //吃货调用wait()方法进入等待状态
                try{
                    bz.wait();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                //被唤醒之后执行代码，吃包子
                System.out.println("吃货正在吃："+bz.pi+bz.xian+"的包子");
                //吃货吃完包子，修改包子的状态为false没有
                bz.flag=false;
                //吃货唤醒包子铺线程，生产包子
                bz.notify();
                System.out.println("吃货已经把："+bz.pi+bz.xian+"的包子吃完了，包子铺开始生产包子");
                System.out.println("------------------------------");
        }
    }
}
测试类
public class Demo{
    public static void main(String[] args){
        //创建包子对象
        BaoZi bz=new BaoZi();
        //创建包子铺线程，开启，生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}

线程池

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
/*
线程池:JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
参数:
int nThreads :创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收(面向接口编程)
java. util. concurrent. ExecutorService:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable task) 提交一个Runnable 任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤;
1.使用线程池的工厂类Executors里边提供的静态方法newF ixedThreadPool生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口，重写run方法，设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类)开启线程,执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
*/

public class Demo{
    public static void main(String[] args){
        System.out.println("");
    }
}


public class Demo01ThreadPool{
    public static void main(String[] args){
        //1.使用线程池的工厂类Executors里边提供的静态方法newF ixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es=Executors.newFixedPool(nThreads:3);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类)开启线程,执行run方法
        es.submit(new RunnableImpl());
        //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();
    }
} 
//2创建一个类，实现Runnable接口，重写run()方法，设置线程任务
public class RunnableImpl implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
    }
}

Lambda表达式

面向对象的思想:
做一件事情,找一个能解决这个事情的对象,调用对象的方法，完成事情.
函数式编程思想:
只要能获取到结果,谁去做的，怎么做的都不重要,重视的是结果，不重视过程

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    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

主要涉及技术：
Java后端开发、
开源爱好者、Linux

联系QQ:1913897461

很惭愧

只做了一点微小的工作
谢谢大家