首页 > > 程序设计 > Java技术 >

【Java并发】基础

2019-10-08 09:15:19来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

【Java并发】基础

  • 一、概述
    • 1.1 线程与进程区别
    • 1.2 多线程引发的性能问题
  • 二、多线程创建方式
    • 2.1 第一种-继承Thread类
    • 2.2 第二种-实现Runnable接口
    • 2.3 第三种-实现Callable接口
    • 2.4 常用线程构造函数
    • 2.5 使用继承Thread类还是使用实现Runnable接口好？
  • 三、线程基础知识
    • 3.1 常用线程API概述
    • 3.2 守护线程
    • 3.3 yield方法
    • 3.4 join()方法作用
    • 3.5 优先级
  • 四、停止线程
    • 4.1 interrupt方法介绍
    • 4.2 判断线程是否是停止状态
    • 4.3 利用异常的方式停止线程
  • 五、多线程运行状态
    • 5.1 线程状态概览
    • 5.2 新建状态(NEW)
    • 5.3 可运行状态(Runnbale)
    • 5.4 阻塞状态(Blocked)
    • 5.5 无限期等待(Waiting)
    • 5.6 限期等待(Timed Waiting)
    • 5.7 死亡(Terminated)

一、概述

1.1 线程与进程区别

  • 进程就是程序的一次执行过程，是系统运行程序的基本单位，进程是动态的。系统运行一个程序就是一个进程从创建、运行到消亡的过程
  • 在Java中，当我们启动main函数的时候就是启动了一个JVM进程，而main函数所在的线程就是这个进程中的一个线程。
  • 每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。
  • 使用线程可以把占据时间长的程序中的任务放到后台去处理，程序的运行速度可能加快，在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下可以释放一些珍贵的资源如内存占用等等。
  • 如果有大量的线程,会影响性能，因为操作系统需要在它们之间切换，更多的线程需要更多的内存空间，线程的中止需要考虑其对程序运行的影响。通常块模型数据是在多个线程间共享的，需要防止线程死锁情况的发生。
  • 总结:进程是所有线程的集合，每一个线程是进程中的一条执行路径。

1.2 多线程引发的性能问题

  • 消耗时间,线程的创建和销毁都需要时间，如果有大量的线程进行创建和销毁，那么这些时间的消耗会比较明显，导致性能上的缺失
  • 非常的消耗CPU和内存：大量的线程创建、执行和销毁是非常的消耗cpu和内存的，这将直接影响系统的吞吐量，导致性能急剧下降，如果内存资源占用的比较多，还很可能造成OOM
  • 容易导致GC频繁的执行：大量的线程的创建和销毁很容易导致GC频繁的执行，从而发生内存抖动现象，而发生了内存抖动，对于移动端来说，最大的影响就是造成界面卡顿
  • 而针对上述所描述的问题，解决的办法归根到底就是：重用已有的线程，从而减少线程的创建。所以这就涉及到线程池（ExecutorService）的概念了，线程池的基本作用就是进行线程的复用。关于线程池的知识，以后再整理

二、多线程创建方式

2.1 第一种-继承Thread类

代码如下:

//1. 继承thread类，重写run方法，run方法中，需要线程执行代码
class ThreadDemo01 extends Thread {
    // run方法中，需要线程需要执行代码
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.print("子线程id:" + this.getId() + ",");
            System.out.print("子线程name:" + getName()+",");
            System.out.println("子线程--->i:" + i);
        }
    }

}
// 1.什么是线程 线程是一条执行路径，每个线程都互不影响。
// 2.什么是多线程，多线程在一个进程中，有多条不同的执行路径，并行执行。目的为了提高程序效率。
// 3.在一个进程中，一定会主线程。
// 4.如果连线程主线程都没有，怎么执行程序。
// 线程几种分类 1. 用户线程、守护线程
//            2. 主线程 子线程 GC线程
public class T001_CreateWithThread {
    // 交替执行
    public static void main(String[] args) {
        System.out.println("main... 主线程开始...");
        // 1.创建线程
        ThreadDemo01 threadDemo01 = new ThreadDemo01();
        // 2.启动线程
        threadDemo01.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main---> i:  " + i);
        }
        System.out.println("main... 主线程结束...");
    }
}

执行结果:

匿名内部类的方式

System.out.println("-----多线程创建开始-----");
new Thread() {
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("线程 -- " + Thread.currentThread().getName() + "-->" + i);
            }
        };

    }.start();
System.out.println("-----多线程创建结束-----");

2.2 第二种-实现Runnable接口

代码如下：

class ThreadDemo02 implements Runnable {
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(" 子 i:" + i);
        }
    }
}

// 1.实现runable接口，重写run方法
public class T002_CreateWithRunnable {
    public static void main(String[] args) {
        System.out.println("main... 主线程开始...");
    
        // 创建线程
        ThreadDemo02 threadDemo02 = new ThreadDemo02();
        /*
        * 这里 用了Thread的另一个构造方法，
        * 该构造方法可以传入一个Runnable的实现类
        * 而我们查看Thread的源码可以得知，Thread类 原本就实现了Runnable
        * 所里也可以传入一个Thread的对象，这样就可以把一个Thread对象中的run()
        * 方法交由其他的线程进行调用
        */
        Thread t1= new Thread(threadDemo02);
        // 启动线程
        t1.start();
        for (int i = 0; i <10; i++) {
            System.out.println("main..i:"+i);
        }
        System.out.println("main... 主线程结束...");
        
    }
}

匿名内部类的方式

System.out.println("-----多线程创建开始-----");
Thread thread = new Thread(new Runnable() {
public void run() {
    for (int i = 0; i< 10; i++) {
        System.out.println("i:" + i);
    }
}
}).start();
System.out.println("-----多线程创建结束-----");

2.3 第三种-实现Callable接口

/**
 * 
 * Callbale接口 可以又返回值，可以抛出异常，
 * 而Runnable接口 中的run方法没有返回值，异常只能捕获
 * 
 * @author hao
 *
 */
public class T002_CreateWithCallable {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<Integer>(mc);
        Thread thread = new Thread(ft);
        thread.start();
        System.out.println(ft.get());
    }
}

class MyCallable implements Callable<Integer> {

    public Integer call() throws Exception {
        
        return 124;
    }
    
}

2.4 常用线程构造函数

  • Thread()，分配一个新的 Thread 对象
  • Thread(String name)，分配一个新的 Thread对象，具有指定的name
  • Thread(Runable target)，分配一个新的 Thread 对象，将target作为其运行对象
  • Thread(Runable target, String name) 分配一个新的Thread对象,将target作为其运行对象，并指定name

2.5 使用继承Thread类还是使用实现Runnable接口好？

  • 使用实现实现Runnable接口好，原因实现了接口还可以继续继承，继承了类不能再继承。
  • 启动线程是使用调用start方法还是run方法？
  • 开始执行线程 注意 开启线程不是调用run方法，而是start方法
  • 用run是使用实例调用方法。

三、线程基础知识

3.1 常用线程API概述

  • start() --->启动线程
  • Thread.currentThread() ---> 获取当前线程对象
  • getID() --->获取当前线程ID
  • getName() --->获取当前线程名称 ，默认的格式为Thread-编号(该编号从0开始)
  • setDaemon(true) ---> 设置为守护线程
  • isAlive() ---> 判断当前的线程是否处于活动状态，线程处于正在运行或者准备开始运行的状态，就认为线程是存活的
  • Thread.sleep(long mill) ---> 休眠线程
  • Thread.yield() ---> 作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间，但是放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片
  • join() ---> 将执行权交由该线程，当前线程进行进入阻塞状态
  • setPriority((int newPriority) ---> 设置线程的优先级，优先级别为1-10，默认为5，10的级别最高
  • stop() ---> 已经过时，慎用，停止线程, 可能造成 stop 后 会将锁释放， 而且有些清理工作可能会没有完成
  • suspend() 和 resume() --->已经过时 , 暂停和恢复 线程 ,会造成线程的独占问题，还有可能会造成数据不同步的情况

3.2 守护线程

  • Java中有两种线程，一种是用户线程，另一种是守护线程。
  • 用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止
  • 守护线程当进程不存在或主线程停止，守护线程也会被停止。典型的守护线程就是垃圾回收线程，当进程中没有非守护线程了，则垃圾回收线程也就没有存在的必要了，自动销毁。
  • 我们可以使用setDaemon(true)方法设置为守护线程

示例

/*
* 什么是守护线程? 守护线程 进程线程(主线程挂了) 守护线程也会被自动销毁.
* 该示例中我们手动将子线程设置为守护线程，
* 当其他线程(该例中只有主线程)停止时守护线程也会终止
*/
public class DaemonThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("我是子线程...");
                }
            }
        });
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {
    
            }
            System.out.println("我是主线程");
        }
        System.out.println("主线程执行完毕!");
    }
    
}

运行结果

3.3 yield方法

  • Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。（可能没有效果）
  • yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。
  • 结论：大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

示例代码

/**
 * yield方法的作用是放弃当前的CPU资源，
 * 将它让给其他的任务去占用CPU执行时间，
 * 但是放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片
 * @author hao
 *
 */
public class T009_Yield {
    public static void main(String[] args) {
        YeildTestThread t1 = new YeildTestThread();
        t1.start();
    }
}

class YeildTestThread extends Thread{
    @Override
    public void run() {
        super.run();
        
        long beginTime = System.currentTimeMillis();
        int count =0;
        for(int i =0;i<5000000;i++) {
            //Thread.yield();
            count = count +(i+1);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("用时："+(endTime-beginTime)+"毫秒！");
        
    }
}

执行结果
注释掉 Thread.yield(); 和没注释掉是的执行时间不同。

3.4 join()方法作用

  • 当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1

代码示例 


//创建一个线程，子线程执行完毕后，主线程才能执行。
public class T010_Join {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {

            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程,i:" + i);
                }
            }
        });
        t1.start();
        // 当前线程释放资格权，等t1执行完毕之后，才会继续进行执行。
        t1.join();
        for (int i = 0; i < 5; i++) {
            System.out.println("main线程,i:" + i);
        }
    }

}

执行结果

应用场景

有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行代码如下：

public class JoinThreadDemo02 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("t1,i:" + i);
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    t1.join();
                } catch (Exception e) {
                }
                for (int i = 0; i < 20; i++) {
                    System.out.println("t2,i:" + i);
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            public void run() {
                try {
                    t2.join();
                } catch (Exception e) {
                }
                for (int i = 0; i < 20; i++) {
                    System.out.println("t3,i:" + i);
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

3.5 优先级

  • 现代操作系统基本采用时分的形式调度运行的线程，线程分配得到的时间片的多少决定了线程使用处理器资源的多少，也对应了线程优先级这个概念。在JAVA线程中，通过一个int priority来控制优先级，范围为1-10，其中10最高，默认值为5。

public class T011_Priority {
    public static void main(String[] args) {
        PrioritytThread prioritytThread = new PrioritytThread();
        Thread t1 = new Thread(prioritytThread);
        Thread t2 = new Thread(prioritytThread);
        t1.start();
        // 注意设置了优先级， 不代表每次都一定会被执行。 只是CPU调度会有限分配
        t1.setPriority(10);
        t2.start();

    }
}
class PrioritytThread implements Runnable {

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().toString() + "---i:" + i);
        }
    }
}

四、停止线程

  • 在Java中有3中方法可以终止正在运行的线程：
  • 使用退出标志，是线程正常退出，也就是当run方法完成后线程终止
  • 使用stop方法强行终止线程，不推荐使用此方法，已过时，调用stop方法后会将锁释放， 而且可能使一些清理性的工作得不到完成。
  • 使用interrupt方法中断线程

4.1 interrupt方法介绍

调用interrupt()方法后线程并没有马上停止，仅仅是在当前线程中打了一个停止的标记，并不是真正的停止线程。

4.2 判断线程是否是停止状态

  • Thread.interrupted(): 测试当前线程是否已经中断,判断的中断状态由该方法清除。如果连续两次调用该方法，则第二次将返回false
  • this.isInterrupted(): 测试线程Thread对象是否已经是中断状态，但不清除状态标记

源码如下

  • 可以看出上面的两个方法都是调用了本地方法 isInterrupted(),通过传入true和false来决定是否要清除中断状态

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

public boolean isInterrupted() {
    return isInterrupted(false);
}

/**
 * Tests if some Thread has been interrupted.  
 * The interrupted state  is reset or not 
 * based on the value of ClearInterrupted that is passed.
 * 
 * 判断某些线程是否已经中断。
 * 根据传入的ClearInterrupted值来决定是否要重置中断的状态
 */
private native boolean isInterrupted(boolean ClearInterrupted);

4.3 利用异常的方式停止线程

/**
 * 利用抛出异常的方式来终止线程
 * @author hao
 *
 */
public class Test_ExceptionInterrupt {
    public static void main(String[] args) {
        try {
            ExcepThread t = new ExcepThread();
            t.start();
            Thread.sleep(2000);
            t.interrupt();
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end！");
    }
}

class ExcepThread extends Thread{
    @Override
    public void run() {
        this.stop();
        try {
            for(int i=0;i<500000;i++) {
                if(Thread.interrupted()) {
                    System.out.println("已经是停止状态了，我要退出了!");
//              break;
                    throw new InterruptedException();
                }
                System.out.println("i "+(i+1));
            }
            System.out.println("我被输出了 。线程并未停止! 只是for循环被中断了");
        } catch (InterruptedException e) {
            System.out.println("catch t ");
            e.printStackTrace();
        }
    }
}

五、多线程运行状态

5.1 线程状态概览

  • 线程从创建、运行到结束总是处于下面五个状态之一：新建状态(NEW)、可运行状态(Runnable)、阻塞状态(Blocked)、无限期等待(Waiting)、限期等待(Timed Waiting)、死亡(Terminated) 如下图：

5.2 新建状态(NEW)

  • 当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。当一个线程处于新生状态时，程序还没有开始运行线程中的代码

5.3 可运行状态(Runnbale)

  • 可能正在运行，也可能正在等待 CPU 时间片。包含了操作系统线程状态中的 Ready 和 Running 状态
  • 就绪状态(Ready)
    • 一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
    • 处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
  • 运行状态(Running)
    • 当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

5.4 阻塞状态(Blocked)

  • 线程试图得到一个锁，而该锁正被其他线程持有；如果其线程释放了锁就会结束此状态。

5.5 无限期等待(Waiting)

  • 等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。

5.6 限期等待(Timed Waiting)

  • 无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。

5.7 死亡(Terminated)

  • 有两个原因会导致线程死亡：
  • run方法正常退出而自然死亡，

  • 一个未捕获的异常终止了run方法而使线程猝死。

  • 为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.


原文链接:https://www.cnblogs.com/haoworld/p/java-bing-fa-ji-chu.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Mybatis面试题吐血总结

下一篇：高并发

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签