JAVA：线程总结及多线程实现的两种方法

最新推荐文章于 2020-08-02 18:08:57 发布
最新推荐文章于 2020-08-02 18:08:57 发布
阅读量1.1k 收藏 16
点赞数 3
分类专栏： JAVA JAVA笔记 文章标签： Thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yang13563758128/article/details/87261957
版权

JAVA：线程总结

目录

 

目录

JAVA：线程总结

JAVA：线程总结

01_多线程(多线程的引入)(了解)

02_多线程(多线程并行和并发的区别)(了解)

03_多线程(Java程序运行原理和JVM的启动是多线程的吗)(了解)

04_多线程(多线程程序实现的方式1)(掌握)

05_多线程(多线程程序实现的方式2)(掌握)

06_多线程(实现Runnable的原理)(了解)

07_多线程(两种方式的区别)(掌握)

08_多线程(匿名内部类实现线程的两种方式)(掌握)

09_多线程(获取名字和设置名字)(掌握)

10_多线程(获取当前线程的对象)(掌握) 

11_多线程(休眠线程)(掌握)

12_多线程(守护线程)(掌握)

13_多线程(加入线程)(掌握)

14_多线程(礼让线程)(了解)

15_多线程(设置线程的优先级)(了解)

16_多线程(同步代码块)(掌握)

17_多线程(同步方法)(掌握)

18_多线程(线程安全问题)(掌握)

19_多线程(火车站卖票的例子用实现Runnable接口)(掌握)

20_多线程(死锁)(了解)

21_多线程(以前的线程安全的类回顾)(掌握)

22_多线程(Timer)(掌握)

23_多线程(两个线程间的通信)(掌握)

24_多线程(三个或三个以上间的线程通信)

25_多线程(JDK1.5的新特性互斥锁)(掌握)

26_多线程(线程组的概述和使用)(了解)

27_多线程(线程的五种状态)(掌握)

28_多线程(线程池的概述和使用)(了解)

29_多线程(多线程程序实现的方式3)(了解)

 

 

 

 

01_多线程(多线程的引入)(了解)
* * 1.什么是线程
*  * 线程是程序执行的一条路径, 一个进程中可以包含多条线程
*  * 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
* * 2.多线程的应用场景
*  * 红蜘蛛同时共享屏幕给多个电脑
*  * 迅雷开启多条线程一起下载
*  * QQ同时和多个人一起视频
*  * 服务器同时处理多个客户端请求
*
2_多线程(多线程并行和并发的区别)(了解)
* * 并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
* * 并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
* * 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
* * 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

03_多线程(Java程序运行原理和JVM的启动是多线程的吗)(了解)
* * A:Java程序运行原理
*  * Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。
*  该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。
*
* * B:JVM的启动是多线程的吗
*  * JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
public class testThread1 {
    public static void main(String []args){
        for (int i = 0; i <3000000 ; i++) {
            new Demo();
        }
        for (int i = 0; i <3000000 ; i++) {
            System.out.println("主线程");
        }
    }
}
class Demo{
    @Override
    protected void finalize()  {
        System.out.println("垃圾回收成功");
    }
}

 

 

04_多线程(多线程程序实现的方式1)(掌握)
多线程两种实现方式
(1)继承Thread
    * 定义类继承Thread
    * 重写run方法
    * 把新线程要做的事写在run方法中
    * 创建线程对象
    * 开启新线程, 内部会自动执行run方法


public class testThread2 {
    public static void main(String []args){
        Test t=new Test();
        //t.run();                    //run()方法是普通方法，要调用start()方法才会开始线程
        t.start();
        for (int i = 0; i <3000000 ; i++) {
            System.out.println("b");
        }
    }
}
class Test extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <3000000; i++) {
            System.out.println("a");
        }
    }
}
05_多线程(多线程程序实现的方式2)(掌握)
(2)实现Runnable
    * 定义类实现Runnable接口
    * 实现run方法
    * 把新线程要做的事写在run方法中
    * 创建自定义的Runnable的子类对象
    * 创建Thread对象, 传入Runnable
    * 调用start()开启新线程, 内部会自动调用Runnable的run()方法
public class testThread3 {
    public static void main(String []args){
        Test1 t=new Test1();
        Thread td=new Thread(t);
        td.start();
        for (int i = 0; i <3000000 ; i++) {
            System.out.println("b");
        }
    }
}
class Test1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <300000 ; i++) {
            System.out.println("a");
        }
    }
}

 

 

06_多线程(实现Runnable的原理)(了解)

实现原理:
    继承Thread    :    由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
    实现Runnable:    构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

07_多线程(两种方式的区别)(掌握)

优缺点:
    继承Thread    :
        好处:    可以直接使用Thread类中的方法,代码简单
        弊端:    如果已经有了父类,就不能用这种方法
    实现Runnable:
        好处:    即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
        弊端:    不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

 

 

08_多线程(匿名内部类实现线程的两种方式)(掌握)
public class testThread4 {
    public static void main(String []args){
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <300000 ; i++) {
                    System.out.println("a");
                }
            }
        }.start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <3000000 ; i++) {
                    System.out.println("b");
                }
            }
        }){

        }.start();
    }
}

 

 

09_多线程(获取名字和设置名字)(掌握)
* * 1.获取名字
*  * 通过getName()方法获取线程对象的名字
* * 2.设置名字
*  * 通过构造函数可以传入String类型的名字
public class testThread5 {
    public static void main(String []args){
        //demo1();
        //通过setName()修改name
        new Thread(){
            @Override
            public void run() {
                this.setName("杨大大");
                System.out.println(this.getName()+"a");             //获取线程名字
            }
        }.start();

    }

    private static void demo1() {
        //通过构造方法给name赋值
        new Thread("杨大大"){
            @Override
            public void run() {
                System.out.println(this.getName()+"a");             //获取线程名字
            }
        }.start();
        new Thread("恒大大"){
            @Override
            public void run() {
                System.out.println(this.getName()+"b");
            }
        }.start();
    }
}

 

 

10_多线程(获取当前线程的对象)(掌握)
* * Thread.currentThread(), 主线程也可以获取
public class testThread6{
    public static void main(String []args){
        new Thread("杨大大"){
            @Override
            public void run() {
                System.out.println(this.getName()+"a");             //获取线程名字
            }
        }.start();
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"b");
            }
        }){

        }.start();
        System.out.println(Thread.currentThread().getName());
    }
}

 

 

11_多线程(休眠线程)(掌握)
* * Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000
public class testThread7 {
    public static void main(String []args) throws InterruptedException {
        //demo1();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <10; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("a");
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("b");
                }
            }
        }.start();
    }

    private static void demo1() throws InterruptedException {
        for (int i = 20; i >=0 ; i--) {
            Thread.sleep(1000);
            System.out.println("倒计时第"+i+"秒");
        }
    }
}

 

 

12_多线程(守护线程)(掌握)
* * setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
*  *
public class testThread8 {
    public static void main(String []args){
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <2 ; i++) {
                    System.out.println(this.getName()+"a");
                }
            }
        };
        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(this.getName()+"b");
                }
            }
        };
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

 

 

13_多线程(加入线程)(掌握)
* * join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
* * join(int), 可以等待指定的毫秒之后继续
public class testThread9 {
    public static void main(String []args){
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println(this.getName()+"a");
                }
            }
        };
        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    if (i==2){
                        try {
                            t1.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(this.getName()+"b");
                }
            }
        };
        t1.start();
        t2.start();
    }
}

 

 

14_多线程(礼让线程)(了解)
* * yield让出cpu
public class testThread10 {
    public static void main(String []args){
        new Test2().start();
        new Test2().start();
    }
}
class Test2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            if (i%10==0){
                Thread.yield();                 //让出cpu
            }
            System.out.println(this.getName()+"aaa"+i);
        }
    }
}

 

 

15_多线程(设置线程的优先级)(了解)
* * setPriority()设置线程的优先级
public class testThread11 {
    public static void main(String []args){
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100; i++) {
                    System.out.println(this.getName()+"a");
                }
            }
        };
        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    System.out.println(this.getName()+"b");
                }
            }
        };
//        t1.setPriority(10);             //设置最大优先级
//        t2.setPriority(1);
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

 

 

16_多线程(同步代码块)(掌握)
* * 1.什么情况下需要同步
*  * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
*  * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
* * 2.同步代码块
*  * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
*  * 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
public class testThread12 {
    public static void main(String []args){
        final Print p=new Print();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    p.print1();
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    p.print2();
                }
            }
        }.start();
    }
}
class  Print{
    test3 t=new test3();
    public void print1(){
        //synchronized (new test3())
        synchronized (t){               //同步代码块，锁机制，锁对象可以是任意的，不是匿名对象，因为匿名对象地址不一样
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }

    }
    public void print2(){
        synchronized (t){
            System.out.print("用");
            System.out.print("心");
            System.out.print("创");
            System.out.print("造");
            System.out.print("\r\n");
        }
    }
}
class test3{

}

 

 

17_多线程(同步方法)(掌握)
* * 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
//非静态的同步方法的锁对象是什么?
//锁对象是this
//静态的同步方法的锁对象是什么?
//锁对象是该类的字节码对象
//同步方法只需要在方法上加synchronized关键字即可
//同步代码块，锁机制，锁对象可以是任意的，不是匿名对象，因为匿名对象地址不一样
public class testThread13 {
    public static void main(String []args){
        final Print p=new Print();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    p.print1();
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    p.print2();
                }
            }
        }.start();
    }
}
class  Print1{
    test3 t=new test3();
    public synchronized void print1(){          //同步方法只需要在方法上加synchronized关键字即可
        synchronized (t){               //同步代码块，锁机制，锁对象可以是任意的，不是匿名对象，因为匿名对象地址不一样
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }

    }
    public void print2(){
        synchronized (t){
            System.out.print("用");
            System.out.print("心");
            System.out.print("创");
            System.out.print("造");
            System.out.print("\r\n");
        }
    }
}
class test4{
}

 

 

18_多线程(线程安全问题)(掌握)
* * 多线程并发操作同一数据时, 就有可能出现线程安全问题
* * 使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
*需求:铁路售票,一共100张,通过四个窗口卖完.
public class test1 {
    public static void main(String []args){
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
    }
}
class Ticket extends Thread{
    private int ticket=100;

    @Override
    public void run() {
        while (true){
            synchronized (Ticket.class){
                if (ticket==0){
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(this.getName()+"这是第"+ticket--+"票");
            }
        }
    }
}

 

 

19_多线程(火车站卖票的例子用实现Runnable接口)(掌握)
public class test2 {
    public static void main(String []args){
        MyTicket t=new MyTicket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();

        /*Thread t1=new Thread(t);
        t1.start();
        t1.start();
        t1.start();
        t1.start();*/                       //多次启动一个线程是非法的
    }
}
class MyTicket implements Runnable{
    private int ticket=100;
    @Override
    public void run() {
        while (true){
            synchronized (Ticket.class){
                if (ticket<=0){
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+"这是第"+ticket--+"票");
            }
        }
    }
}

 

 

20_多线程(死锁)(了解)
* * 多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
*  * 尽量不要嵌套使用
public class testThread14 {
    private static String s1="筷子左";
    private static String s2="筷子右";
    public static void main(String []args){
        new Thread(){
            @Override
            public void run() {
                    while (true){
                        synchronized (s1) {
                            System.out.println(this.getName()+"获取" + s1+"等待"+s2);
                            synchronized (s2){
                                System.out.println(this.getName()+"拿到"+s2+"开吃");
                            }
                        }
                    }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    synchronized (s2) {
                        System.out.println(this.getName()+"获取" + s2+"等待"+s1);
                        synchronized (s1){
                            System.out.println(this.getName()+"拿到"+s1+"开吃");
                        }
                    }
                }
            }
        }.start();
    }
}

 

 

21_多线程(以前的线程安全的类回顾)(掌握)
//        * A:回顾以前说过的线程安全问题
//        * 看源码：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
//        * Vector是线程安全的,ArrayList是线程不安全的
//        * StringBuffer是线程安全的,StringBuilder是线程不安全的
//        * Hashtable是线程安全的,HashMap是线程不安全的

22_多线程(Runtime类)

public class testRunTime1 {
    public static void main(String []args) throws IOException {
       Runtime r=Runtime.getRuntime();
       r.exec("shutdown -s -t 300");
       r.exec("shutdown -a");
    }
}

23_多线程(Timer)(掌握)

public class testTimer1 {
    public static void main(String []args) throws InterruptedException {
        Timer t=new Timer();
        t.schedule(new MyTimerTask(),new Date(188,1,14,14,46,1),1);
        while (true){
            Thread.sleep(1000);
            System.out.println(new Date());
        }
    }
}
class MyTimerTask extends TimerTask{
    @Override
    public void run() {
        System.out.println("起床");
    }
}

24_多线程(两个线程间的通信)(掌握)

* 1.什么时候需要通信
   * 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
   * 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
* 2.怎么通信
   * 如果希望线程等待, 就调用wait()
   * 如果希望唤醒等待的线程, 就调用notify();
   * 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

public class testNotify1 {
    public static void main(String []args){
        final Print p=new Print();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

    }
}

class Print {
    private int flag=1;
    public void print1() throws InterruptedException {
        synchronized (this){
            if (flag!=1){
                this.wait();
            }
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.println("\r\n");
            flag=2;
            this.notify();              //随机唤醒单个等待线程
        }
    }
    public void print2() throws InterruptedException {
        synchronized (this){
            if (flag!=2){
                this.wait();
            }
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.println("\r\n");
            flag=1;
            this.notify();
        }
    }
}

25_多线程(三个或三个以上间的线程通信)

* 多个线程通信的问题
   * notify()方法是随机唤醒一个线程
   * notifyAll()方法是唤醒所有线程
   * JDK5之前无法唤醒指定的一个线程
   * 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件
1.在同步代码块中，用哪个对象所=锁就用哪个对象调用weit方法
*2.为什么wait和notify方法定义在Object?
* 因为锁对象可以是任意的
* 3.sleep方法和wait方法的区别?
* sleep方法必须传入参数，参数是时间，时间到了会自动醒来
* wait方法可以传入参数也可以不传入参数，传入参数就是在参数的时间结束后等待v，不传入参数就是直接等待
*sleep方法在同步函数或同步代码块中不释放锁
* wait方法在同步函数或同步代码块中释放锁


public class testNotify2 {
    public static void main(String []args){
        final Print2 p=new Print2();
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.print1();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.print2();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        new Thread(){
            @Override
            public void run() {
                while (true){
                    try {
                        p.print3();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
    }
}
class Print2 {
    private int flag=1;
    public void print1() throws InterruptedException {
        synchronized (this){
            while (flag!=1){
                this.wait();
            }
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.println("\r\n");
            flag=2;
            //this.notify();              //随机唤醒单个等待线程
            this.notifyAll();
        }
    }
    public void print2() throws InterruptedException {
        synchronized (this){
            while (flag!=2){
                this.wait();
            }
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.println("\r\n");
            flag=3;
            //this.notify();
            this.notifyAll();
        }
    }
    public void print3() throws InterruptedException {
        synchronized (this) {
            while (flag != 3) {            //线程3在此等待，if在哪里等待，就在哪里起来
                this.wait();
            }                           //while循环是循环判断，每次都会判断
            System.out.print("i");
            System.out.print("t");
            System.out.print("hei");
            System.out.print("ma");
            System.out.println("\r\n");
            flag = 1;
            //this.notify();
            this.notifyAll();
        }
    }
}

26_多线程(JDK1.5的新特性互斥锁)(掌握)

* 1.同步
   * 使用ReentrantLock类的lock()和unlock()方法进行同步
* 2.通信
   * 使用ReentrantLock类的newCondition()方法可以获取Condition对象
   * 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
   * 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

public class testLock1 {
    public static void main(String []args){
        Print3 p=new Print3();
        new Thread(){
            @Override
            public void run() {
                try {
                    p.print1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    p.print2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    p.print3();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();

    }
}
class Print3 {
    private ReentrantLock r=new ReentrantLock();
    private Condition c1=r.newCondition();
    private Condition c2=r.newCondition();
    private Condition c3=r.newCondition();
    private int flag=1;
    public void print1() throws InterruptedException{
        r.lock();
        if (flag!=1){
                c1.await();
            }
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.println("\r\n");
            flag=2;
            //this.notify();              //随机唤醒单个等待线程
            c2.signal();
        r.unlock();
    }
    public void print2() throws InterruptedException {
        r.lock();
            if (flag!=2){
                c2.await();
            }
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.println("\r\n");
            flag=3;
            //this.notify();
            c3.signal();
        r.unlock();
    }
    public void print3() throws InterruptedException {
        r.lock();
            if (flag != 3) {            //线程3在此等待，if在哪里等待，就在哪里起来
                c3.await();
            }                           //while循环是循环判断，每次都会判断
            System.out.print("i");
            System.out.print("t");
            System.out.print("hei");
            System.out.print("ma");
            System.out.println("\r\n");
            flag = 1;
            //this.notify();
            c1.signal();
        r.unlock();
    }
}

27_多线程(线程组的概述和使用)(了解)

* A:线程组概述
   * Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
   * 默认情况下，所有的线程都属于主线程组。
      * public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
      * public final String getName()//通过线程组对象获取他组的名字
   * 我们也可以给线程设置分组
      * 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
      * 2,创建线程对象
      * 3,Thread(ThreadGroup?group, Runnable?target, String?name) 
      * 4,设置整组的优先级或者守护线程
   * B:案例演示
      * 线程组的使用,默认是主线程组

public class testThreadGroup1 {
    public static void main(String []args){
        //demo1();
        ThreadGroup tg=new ThreadGroup("我是一个新的线程组");            //创建新的线程组
        MyRunnable mr=new MyRunnable();
        Thread t1=new Thread(tg,mr,"张三");
        Thread t2=new Thread(tg,mr,"李四");
        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());
    }

    private static void demo1() {
        MyRunnable mr=new MyRunnable();
        Thread t1=new Thread(mr,"张三");
        Thread t2=new Thread(mr,"李四");
        ThreadGroup tg1=t1.getThreadGroup();
        ThreadGroup tg2=t2.getThreadGroup();
        System.out.println(tg1.getName());
        System.out.println(tg2.getName());
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(Thread.currentThread().getName()+"a"+i);
        }
    }
}

28_多线程(线程的五种状态)(掌握)

29_多线程(线程池的概述和使用)(了解)

* A:线程池概述
   * 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池
* B:内置线程池的使用概述
   * JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
      * public static ExecutorService newFixedThreadPool(int nThreads)
      * public static ExecutorService newSingleThreadExecutor()
      * 这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
      * Future<?> submit(Runnable task)
      * <T> Future<T> submit(Callable<T> task)
   * 使用步骤：
      * 创建线程池对象
      * 创建Runnable实例
      * 提交Runnable实例
      * 关闭线程池
   * C:案例演示

public class testCallable1 {
    public static void main(String []args) throws ExecutionException, InterruptedException {
        ExecutorService pool= Executors.newFixedThreadPool(2);
        Future<Integer> f1=pool.submit(new MyCallable(100));          //将线程放进线程池并执行
        Future<Integer> f2=pool.submit(new MyCallable(50));
        System.out.println(f1.get());
        System.out.println(f2.get());
        pool.shutdown();
    }
}
class MyCallable implements Callable<Integer>{
    private int num;

    public MyCallable(int num) {
        this.num = num;
    }

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 1; i <=num ; i++) {
            sum+=1;
        }
        return sum;
    }
}
提交的是Callable
* * 多线程程序实现的方式3的好处和弊端
*  * 好处：
*     * 可以有返回值
*     * 可以抛出异常
*
*  * 弊端：
*     * 代码比较复杂，所以一般不用
lhyangtop
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java中实现线程的两种方式
pipizhen_的博客
07-24 2563
关于多线程的基本概述： 什么是进程？什么是线程？ 进程是一个应用程序。 线程是一个进程中执行场景，执行单元。 一个进程可以启动多个线程。 进程与进程之间内存独立不共享。 在java语言中： 任意两个线程与线程之间，堆内存和方法区内存共享，因为堆内存和方法区只有一个。 但是栈内存独立，一个线程一个栈。栈内存有很多个。 假设有10个线程，会有10个栈空间，每个栈之间互不干扰，各自执行。 这就是多线程并发执行。 java中之所以有多线程机制，目的就是为了提高程序的效率。 思考：使用了多线程机制之后，main()方
java 多线程两种方式_JAVA多线程实现的两种方式
weixin_29638987的博客
02-16 1901
java多线程实现方式主要有两种：继承Thread类、实现Runnable接口1、继承Thread类实现多线程继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()...
48、线程概念
JavaDayUp
11-04 1047
学习目标： 1、了解线程的基本概念 2、了解Thread线程类的使用 3、了解Runnable接口的使用 4、了解Callable接口的使用 学习过程： 一、线程概念 现代的操作系统都是多用户多进程分时操作系统，所以我们在使用操作系统时，可以一边听歌，一边下载，还可以聊天等等，事实上我们的操作系统同时还运行着很多后台进程，你可以打开window系统的任务管理器就可以看到很多进程在运行...
什么是多线程？实现多线程有哪俩种编程方式
weixin_45969382的博客
05-29 1068
在单个进程中可以有一个或者多个线程，同时运行多个线程完成不同的工作，称为多线程。也就是说，允许单个程序创建多个并同时执行的线程来完成各自的子任务，也成为多线程编程。 java中的多线程就是在操作系统每次分给Java程序（进程）一个时间片段的CPU时间内，在若干独立可控制的线程之间切换。java应用程序中具有main()方法的主类(或init()),通过main（）方法开始执行,java虚拟机（JVM）就会认为一个主线程启动。 而后在main()方法的执行中再创建的线程，就成为程序中的其他线程。java虚拟
Java启动线程两种方式总结
.
07-12 9389
先查看jdk帮助文档，这么进行描述线程：线程是程序中的执行线程，可以由jvm来运行一个或者多个线程。 方法1：继承Thread 类 重写run方法即可 如下代码： public class Treadtest { //主方法 public static void main(String[] args) throws InterruptedException { Thre...
JAVA多线程的两种实现方法
koozxcv的博客
12-24 406
Java中实现多线程有两种方法：继承Thread类、实现Runnable接口，在程序开发中只要是多线程，肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下优势：     1、可以避免由于Java的单继承特性而带来的局限；     2、增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的；     3、适合多个相同程序代码的线程
java多线程总结一：线程的两种创建方式及优劣比较
Touch_2011的专栏
10-20 1万+
1、通过实现Runnable接口线程创建 (1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。 (2).创建Runnable接口实现类的对象。 (3).创建一个Thread类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承） (4).调用Thread对象的start()方法，启动线程 示例代码：
java 多线程的几种实现方法总结
08-29
在 Java 中，同步的实现方法有两种：使用 synchronized 关键字和使用 wait、notify、notifyAll 方法。使用 synchronized 关键字可以使得某个方法或代码块在多线程中同步执行，而使用 wait、notify、notifyAll 方法...
JAVA实现多线程的两种方法实例分享
09-05
在 Java 中实现多线程主要有两种方法：继承 `Thread` 类和实现 `Runnable` 接口。这两种方法都可以帮助我们创建和管理线程，但它们各自有不同的适用场景和优缺点。 ### 1. 继承 `Thread` 类 当你创建一个新的类去...
Java多线程-对比创建多线程的两种方式
最新发布
01-25
Java多线程编程中，创建线程主要有两种方式：继承`Thread`类和实现`Runnable`接口。这两种方式虽然都能实现多线程，但它们在实际应用中有着不同的特性和适用场景。 首先，我们来看看继承`Thread`类的方式。这种方式...
java线程：两种传统的实现方式.zip
03-12
本文将深入探讨两种传统的Java线程实现方式，并通过一个具体的例子来阐述如何创建和管理这些线程。 首先，我们来看第一种线程实现方式：继承`Thread`类。当你创建一个新的类继承自`java.lang.Thread`，你可以重写它...
Java多线程实现的两种方式
08-31
本文将深入探讨Java实现多线程的两种主要方式：继承`Thread`类和实现`Runnable`接口。 1. 继承`Thread`类实现多线程 当你需要创建一个新的线程类并且不与已有的类发生冲突时，可以考虑使用继承`Thread`类的方式。...
实现多线程的两种方式
qq_41927743的博客
08-05 1823
实现多线程的两种方式 一、什么是线程？ 定义：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。 简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程 二、怎么实现多线程？ 下面的两种方式妇孺皆知 1.继承Thread类 package com.hc.thread; public cla...
多线程的几种实现方式
热门推荐
swain_yj的博客
08-02 3万+
先上总结： 1.使用实现多线程有四种方式：①继承Thread类；②实现Runnable接口；③使用Callable和FutureTask实现有返回值的多线程；④使用ExecutorService和Executors工具类实现线程池(如果需要线程的返回值，需要在线程中实现Callable和Future接口) 2.继承Thread类的优点：简单，且只需要实现父类的run方法即可(start方法中含有run方法，会创建一个新的线程，而run是执行当前线程)。缺点是：Java的单继承，如果对象已经继承了其他的类
java创建线程的两种方式及区别
逆水行舟，不进则退
07-24 3691
本文将介绍创建线程的两种方式，示例代码在下面，复制粘贴即可 继承Thread类方式和实现Runnable接口方式 区别：由于在开发的过程中，很多的类都会用到继承的方式，如果采用继承的方式会让各个类之间的关系变得错综复杂 使得程序的可读性变差，所以在开发当中一般都用实现接口的方式，而且实现接口的方式还可以共享资源，共享资源的 示例将在以后列出。 /*  * 创建线程的第一种方式：继承方式...
java实现多线程的两种方法
Hyfslw的博客
03-02 233
java实现多线程的两种方法 第一：进行Thread Class的继承 class method1 extends Thread｛ //实现方法run public void run（） ｛ //在这里进行需要的操作 获取当前线程Thread.curre...
数据库:MySQL和MariaDB的JDBC连接
岁月求索
05-26 2万+
目录 QUESTION:MySQL和MariaDB的JDBC连接？ ANSWER: 区别与联系： MySQL： MariaDB： java连接mariaDB数据库的设置：(tomcat 8) 第一种方法：使用tomcat自带的mysql-connector-java-5.1.40-bin.jar： 第二种，使用mariadb的jdbc Driver： QUESTION:My...
Java多线程实战：继承Thread与实现Runnable的方法
总结来说，Java中实现多线程有两种主要方式：继承Thread类和实现Runnable接口。无论选择哪种方式，理解线程的生命周期和正确调用start()方法至关重要。同时，Java线程调度策略、同步控制（如synchronized关键字）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lhyangtop

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值