J2SE（5）Java多线程机制

最新推荐文章于 2021-09-11 00:09:05 发布
最新推荐文章于 2021-09-11 00:09:05 发布
阅读量202 收藏 1
点赞数
文章标签： J2SE Java多线程机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ma_xiao_shuai/article/details/89422145
版权

1、线程的及基本概念：
（1）、线程是一个程序内部的顺序控制流（线程是一个程序里面不同的执行路径）。
（2）、线程和进程的区别：
a、每个进程都有独立的代码和数据空间，进程间的切换会有较大的开销。
b、线程可以看成时轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器，线程切换的开销小。
c、多进程：在操作系统中能同时运行多个任务。
d、多线程：在同一个应用程序中有多个顺序流同时执行。
***学习线程首先要理清楚三个概念：
（1）、进程：进程是一个静态的概念
（2）、线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。
（3）、 在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。
　　 （4）、什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

2、Java线程的实现：
（1）、java线程是通过java.lang.Thread类来实现的
（2）、虚拟机（JVM）启动时会有一个由主方法（public static void main( ) { }） 所定义的线程。
（3）、可以通过创建Thread的实例来创建新的线程。
（4）、每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。
（5）、通过调用Thead类的start( )方法来启动一个线程。

3、线程的创建：
（1）、第一种：
* 定义线程类实现Runnable接口。
* Thread myThread = new Thread(target) //target为Runnable接口类型。
* Runnable中只有一个方法：public void run( ); 用以定义线程运行体。
* 使用Runnable接口可以为多个线程提供共享数据。
* 在实现Runnable接口类的run方法定义中可以使用Thread的静态方法：public static Thread currentThread( ) 获取当前线程的引用。
* 例：

package cn.galc.test;


public class TestThread1{
    public static void main(String args[]){
        Runner1 r1 = new Runner1();//这里new了一个线程类的对象出来
        //r1.run();//这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法
        Thread t = new Thread(r1);//要启动一个新的线程就必须new一个Thread对象出来
        //这里使用的是Thread(Runnable target) 这构造方法
        t.start();//启动新开辟的线程，新线程执行的是run()方法，新线程与主线程会一起并行执行
        for(int i=0;i<10;i++){
            System.out.println("maintheod："+i);
        }
    }
}
/*定义一个类用来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类*/
class Runner1 implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("Runner1："+i);
        }
    }
}

（2） 、第二种：

  • 可以定义一个Thread的子类并重写其run方法。如：
class MyThread extends Thread {
    public void run(){...}
}
  • 然后生成该类对象：MyThread myThread = new MyThread(…)
    例：
package cn.galc.test;


/*线程创建与启动的第二种方法：定义Thread的子类并实现run()方法*/
public class TestThread2{
    public static void main(String args[]){
        Runner2 r2 = new Runner2();
        r2.start();//调用start()方法启动新开辟的线程
        for(int i=0;i<=10;i++){
            System.out.println("mainMethod："+i);
        }
    }
}
/*Runner2类从Thread类继承
通过实例化Runner2类的一个对象就可以开辟一个新的线程
调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
class Runner2 extends Thread{
    public void run(){//重写run()方法的实现
        for(int i=0;i<=10;i++){
            System.out.println("Runner2："+i);
        }
    }
}

***使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个，而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。

4、线程状态装换：
在这里插入图片描述5、线程控制基本方法：
在这里插入图片描述6、sleep/join/yield 方法:
（1）、sleep方法
* 可以调用Thread的静态方法：public static void sleep(long millis) throws InterruptedException 使得当前线程休眠（暂时停止执行millis毫秒）。
* 由于是静态方法，sleep可以由类名直接调用：Thread.sleep(…)
* 例：

package cn.galc.test;


import java.util.*;


public class TestThread3 {
    public static void main(String args[]){
        MyThread thread = new MyThread();
        thread.start();//调用start()方法启动新开辟的线程
        try {
            /*Thread.sleep(10000);
            sleep()方法是在Thread类里面声明的一个静态方法，因此可以使用Thread.sleep()的格式进行调用
            */
            /*MyThread.sleep(10000);
            MyThread类继承了Thread类，自然也继承了sleep()方法，所以也可以使用MyThread.sleep()的格式进行调用
            */
            /*静态方法的调用可以直接使用“类名.静态方法名”
              或者“对象的引用.静态方法名”的方式来调用*/
            MyThread.sleep(10000);
            System.out.println("主线程睡眠了10秒种后再次启动了");
            //在main()方法里面调用另外一个类的静态方法时，需要使用“静态方法所在的类.静态方法名”这种方式来调用
            /*
            所以这里是让主线程睡眠10秒种
            在哪个线程里面调用了sleep()方法就让哪个线程睡眠，所以现在是主线程睡眠了。
            */
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
        thread.flag=false;//改变循环条件，结束死循环
        /**
         * 当发生InterruptedException时，直接把循环的条件设置为false即可退出死循环，
         * 继而结束掉子线程的执行，这是一种比较好的结束子线程的做法
         */
        /**
         * 调用interrupt()方法把正在运行的线程打断
        相当于是主线程一盆凉水泼上去把正在执行分线程打断了
        分线程被打断之后就会抛InterruptedException异常，这样就会执行return语句返回，结束掉线程的执行
        所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
         */
    }
}


class MyThread extends Thread {
    boolean flag = true;// 定义一个标记，用来控制循环的条件


    public void run() {
        /*
         * 注意：这里不能在run()方法的后面直接写throw Exception来抛异常，
         * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
         *  所以这里只能写try……catch()来捕获异常
         */
        while (flag) {
            System.out.println("==========" + new Date().toLocaleString() + "===========");
            try {
                /*
                 * 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
                 */
                // MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
                sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
                // 这里是让这个新开辟的线程每隔一秒睡眠一次，然后睡眠一秒钟后再次启动该线程
                // 这里在一个死循环里面每隔一秒启动一次线程，每个一秒打印出当前的系统时间
            } catch (InterruptedException e) {
                /*
                 * 睡眠的时一盘冷水泼过来就有可能会打断睡眠
                 * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
                 */
                return;
                // 线程被中断后就返回，相当于是结束线程
            }
        }
    }
}

（2）、join方法

  • 合并某个线程。
  • 例：
package cn.galc.test;


public class TestThread4 {
    public static void main(String args[]) {
        MyThread2 thread2 = new MyThread2("mythread");
        // 在创建一个新的线程对象的同时给这个线程对象命名为mythread
        thread2.start();// 启动线程
        try {
            thread2.join();// 调用join()方法合并线程，将子线程mythread合并到主线程里面
            // 合并线程后，程序的执行的过程就相当于是方法的调用的执行过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}


class MyThread2 extends Thread {
    MyThread2(String s) {
        super(s);
        /*
         * 使用super关键字调用父类的构造方法
         * 父类Thread的其中一个构造方法：“public Thread(String name)”
         * 通过这样的构造方法可以给新开辟的线程命名，便于管理线程
         */
    }


    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("I am a\t" + getName());
            // 使用父类Thread里面定义的
            //public final String getName()，Returns this thread's name.
            try {
                sleep(1000);// 让子线程每执行一次就睡眠1秒钟
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

（3）、yield方法
* 让出CPU，给其他线程执行的机会。
* 例：

package cn.galc.test;


public class TestThread5 {
    public static void main(String args[]) {
        MyThread3 t1 = new MyThread3("t1");
        /* 同时开辟了两条子线程t1和t2，t1和t2执行的都是run()方法 */
        /* 这个程序的执行过程中总共有3个线程在并行执行，分别为子线程t1和t2以及主线程 */
        MyThread3 t2 = new MyThread3("t2");
        t1.start();// 启动子线程t1
        t2.start();// 启动子线程t2
        for (int i = 0; i <= 5; i++) {
            System.out.println("I am main Thread");
        }
    }
}


class MyThread3 extends Thread {
    MyThread3(String s) {
        super(s);
    }


    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(getName() + "：" + i);
            if (i % 2 == 0) {
                yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
                /*
                 * 在程序的运行的过程中可以看到，
                 * 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行
                 * 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
                 */
            }
        }
    }
}

7、线程的优先级：
（1）、java提供一个线程调度器来监控程序启动后进入就绪状态的所有线程，线程调度器按照线程的优先级决定应调度那个线程来执行。
（2）、线程的优先级用数字表示，范围从1到10，一个线程的默认优先级是5。
* Thread.MIN_PRIORITY = 1
* Thread.MIN_PRIORITY = 10
* Thread.NORM_PRIORITY = 5

（3）、使用下述方法获得或设置线程对象的优先级：

  • int getPriority( );
  • void setPriority(int newPriority)；
  • 例：
package cn.galc.test;


public class TestThread6 {
    public static void main(String args[]) {
        MyThread4 t4 = new MyThread4();
        MyThread5 t5 = new MyThread5();
        Thread t1 = new Thread(t4);
        Thread t2 = new Thread(t5);
        t1.setPriority(Thread.NORM_PRIORITY + 3);// 使用setPriority()方法设置线程的优先级别，这里把t1线程的优先级别进行设置
        /*
         * 把线程t1的优先级(priority)在正常优先级(NORM_PRIORITY)的基础上再提高3级
         * 这样t1的执行一次的时间就会比t2的多很多 　　　　
         * 默认情况下NORM_PRIORITY的值为5
         */
        t1.start();
        t2.start();
        System.out.println("t1线程的优先级是：" + t1.getPriority());
        // 使用getPriority()方法取得线程的优先级别，打印出t1的优先级别为8
    }
}


class MyThread4 implements Runnable {
    public void run() {
        for (int i = 0; i <= 1000; i++) {
            System.out.println("T1：" + i);
        }
    }
}


class MyThread5 implements Runnable {
    pub8lic void run() {
        for (int i = 0; i <= 1000; i++) {
            System.out.println("===============T2：" + i);
        }
    }
}

8、线程同步：
（1）、在Java语言中，引入了对象互斥锁的概念，保证共享数据的完整性。每个对象都对应于一个可称为“互斥锁”的标记，这个标记保证在任意时刻，只能有一个线程访问该对象。
（2）、关键字synchronized来与对象的互斥锁联系，当某个对象被synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
（3）、synchronized的使用方法：

package cn.galc.test;


public class TestSync implements Runnable {
    Timer timer = new Timer();


    public static void main(String args[]) {
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.setName("t1");// 设置t1线程的名字
        t2.setName("t2");// 设置t2线程的名字
        t1.start();
        t2.start();
    }


    public void run() {
        timer.add(Thread.currentThread().getName());
    }
}


class Timer {
    private static int num = 0;


    public/* synchronized */void add(String name) {// 在声明方法时加入synchronized时表示在执行这个方法的过程之中当前对象被锁定
        synchronized (this) {
            /*
             * 使用synchronized(this)来锁定当前对象，这样就不会再出现两个不同的线程同时访问同一个对象资源的问题了 只有当一个线程访问结束后才会轮到下一个线程来访问
             */
            num++;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "：你是第" + num + "个使用timer的线程");
        }
    }
}

***synchronized还可以放在方法声明中，表示整个方法为同步方法。例：synchronized public void add(String name){…}

9、线程死锁问题：
（1）、死锁：
在这里插入图片描述（2）、例：

package cn.galc.test;


/*这个小程序模拟的是线程死锁的问题*/
public class TestDeadLock implements Runnable {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();


    public void run() {
        System.out.println(Thread.currentThread().getName() + "的flag=" + flag);
        /*
         * 运行程序后发现程序执行到这里打印出flag以后就再也不往下执行后面的if语句了
         * 程序也就死在了这里，既不往下执行也不退出
         */


        /* 这是flag=1这个线程 */
        if (flag == 1) {
            synchronized (o1) {
                /* 使用synchronized关键字把对象01锁定了 */
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o2) {
                    /*
                     * 前面已经锁住了对象o1，只要再能锁住o2，那么就能执行打印出1的操作了
                     * 可是这里无法锁定对象o2，因为在另外一个flag=0这个线程里面已经把对象o1给锁住了
                     * 尽管锁住o2这个对象的线程会每隔500毫秒睡眠一次，可是在睡眠的时候仍然是锁住o2不放的
                     */
                    System.out.println("1");
                }
            }
        }
        /*
         * 这里的两个if语句都将无法执行，因为已经造成了线程死锁的问题
         * flag=1这个线程在等待flag=0这个线程把对象o2的锁解开，
         * 而flag=0这个线程也在等待flag=1这个线程把对象o1的锁解开
         * 然而这两个线程都不愿意解开锁住的对象，所以就造成了线程死锁的问题
         */


        /* 这是flag=0这个线程 */
        if (flag == 0) {
            synchronized (o2) {
                /* 这里先使用synchronized锁住对象o2 */
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (o1) {
                    /*
                     * 前面已经锁住了对象o2，只要再能锁住o1，那么就能执行打印出0的操作了 可是这里无法锁定对象o1，因为在另外一个flag=1这个线程里面已经把对象o1给锁住了 尽管锁住o1这个对象的线程会每隔500毫秒睡眠一次，可是在睡眠的时候仍然是锁住o1不放的
                     */
                    System.out.println("0");
                }
            }
        }
    }


    public static void main(String args[]) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 0;
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.setName("线程td1");
        t2.setName("线程td2");
        t1.start();
        t2.start();
    }
}
马晓帅
关注
j2se练习代码 Java学习资料
06-25
J2SE提供了丰富的API，包括I/O流、网络编程、多线程、集合框架、数据库连接等，这些都是Java程序员必须掌握的基础知识。在这个压缩包中，你可以找到一系列针对这些主题的练习代码，通过实践来加深对Java的理解。 在...
j2se5.rar_J2SE 架构_j2se
09-24
文件"j2se5.gif"可能是一个详细的J2SE架构图，它可能展示了J2SE的主要组件，如虚拟机（JVM）、类加载器、核心类库、异常处理、多线程模型等。而"www.pudn.com.txt"可能是下载资源的来源信息或者相关说明，对于理解...
Java线程的几种状态
fingthinking的博客
04-17 322
新建( new )：新创建了一个线程对象。 可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象 的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取 cpu 的使用权 。 运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ） ，执行程序代码。 阻塞( block
线程讲解
makao45683968的博客
05-26 121
:wink: Java多线程机制 johnston678 原创 更新：2009-05-06 20:41:00 版本: 1.0 一 线程的基本概念 线程是一个程序内部的顺序控制流.一个进程相当于一个任务,一个线程相当于一个任务中的一条执行路径. 多进程:在操作系统中能同时运行多个任务(程序) 多线程:在同一个应用程序中有多个顺序流同时执行 Java的线程是通...
java多线程机制
01-10 3427
一、进程与线程 1.1、任务调动 大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。 多任务运行过程的示意图如下： 1.1操作系统中的任务调度 1.2 进程 我们都知道计算机的核心是CPU，它承担了所有的计算任务；而操作系统是计算机
java的多线程机制
wangdong的博客
07-30 787
什么是线程？    在操作系统中，通常将进程看作系统资源的分配单位和独立运行的基本单位。一个任务就是一个进程。线程是比进程更小的·执行单位。那什么是线程呢,线程是比进程更小的执行单位，是程序执行流的最小单位。一个标准的线程由线程ID、当前指令指针PC、寄存器集合和堆栈组成。另外线程是进程中的一个实体，是被系统独立调度和分配的基本单位，线程自己不拥有系统资源，只拥有运行中必不可少的资源。 线程的...
Java多线程机制（一）
mysky984的博客
09-22 390
文章目录Java多线程机制一、线程的基本概念二、线程的创建和启动三、线程状态转换四、线程控制的基本方法五、线程的优先级 Java多线程机制 一、线程的基本概念 概念： 线程是一个程序内部的顺序控制流 线程和进程区别： （1）每个进程都有独立的代码和数据空间，进程间的切换会有较大的开销。 （2）线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线...
java_movestar.rar_j2se_线程控制
09-24
这个项目可能采用了其中的一种或两种方法，让星星在屏幕上移动，这涉及到了多线程的同步和通信问题。 首先，我们可能会看到一个自定义的Thread类或Runnable实现，用于描绘星星的移动逻辑。在这个类中，重写`run()`...
JMS.J2SE.application.programming.code.rar_j2se_java programming
09-24
5. **可扩展性**: 系统可以通过增加更多的消费者来处理增加的工作负载，无需修改现有代码。 在J2SE环境中使用JMS，开发者需要了解以下关键概念： - **消息**: 是数据的载体，可以是文本、XML、二进制数据等。 - **...
java-j2se.rar_j2se
09-19
J2SE提供了丰富的API和工具，使得开发者能够构建健壮、可移植、多线程和安全的软件。本压缩包文件“java-j2se.rar_j2se”包含了对Java基础知识的复习材料和面试题目，旨在帮助学习者巩固Java编程技能，准备面试。 ...
Java多线程机制
qq_42447739的博客
09-11 562
java线程： 多线程是指一个应用程序中同时存在几个执行体，但是我们的计算机在任何给定的时刻只能执行那些线程中的一个。 主线程： java应用程序总是主类的main方法开始执行，当JVM加载代码，发现main方法之后，就会开启一个线程“主线程”，当main方法执行完最后一个语句，即main方法返回时，JVM就要结束java应用程序。 线程的状态和生命周期： ava语言使用Thread类以及子类的对象来表示线程。 线程有4种状态，分别为新建，运行，中断，死亡 新建：创建对象并且声明时 运行：线程创建之后就具备
J2SE基础学习：从Java概述到多线程机制
"这篇资料主要介绍了J2SE的学习，涵盖了从基础到高级的多个主题，包括JAVA概述、语言基础、面向对象编程、异常处理、数组、常用类、容器类、流技术、多线程机制、网络编程以及GUI编程。特别强调了继承关系的一般和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值