【Java并发】基础

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【Java并发】基础，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14022字，纯文字阅读大概需要21分钟。

内容图文

一、概述
- 1.1 线程与进程区别
- 1.2 多线程引发的性能问题
二、多线程创建方式
三、线程基础知识
四、停止线程
五、多线程运行状态

一、概述

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.

内容总结

以上是互联网集市为您收集整理的【Java并发】基础全部内容，希望文章能够帮你解决【Java并发】基础所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/700400.html

来源：【匿名】

【上一篇】java基础（6）---IO流【下一篇】JAVA/JSP学习系列之五

更多 ►

【【Java并发】基础】教程文章相关的互联网学习教程文章

1、final, finally, finalize的区别final：修饰符（关键字）如果一个类被声明为final，没有子类也不能被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后不可修改。被声明为final的方法也同样只能使用，不能重载finally：再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配...

黑马程序猿——JAVA基础——集合

----------android培训、java培训、java学习型技术博客、期待与您交流。------------ 一、关于java中的集合类首先看一下，大致的框架流程图通过这些我们能够看出来，通常我们常常採用的vector、arraylist、hashset。treeset，hashmap。hashtable，treemap、linkedlist类关于vector和arraylist对照，vector是线程安全的，vector通过遍历。性能更高。ArrayList和Vector功能类似。Vector从Java 1.0起就存在，ArrayList从...

Java：基础

Hello World//HelloWorld.java文件public class HelloWorld{public static void main(String[] args){ System.out.println(“Hello World!”); }} 编译运行javac HelloWorld.java 编译生成HelloWorld.classjava HelloWorld 运行main方法变量存储大小例值注释byte1byte3字节int4bytes3整数short2bytes3短整数long8bytes3长整数float4bytes1.2单精度浮点数double8bytes1.2双精度浮点数char2bytes‘a’字符boolean1bittrue...

java基础：interface

一：例子二：总结1:接口是抽象方法和常量值定义的集合 2：从本质上讲，接口是一种特殊的抽象类，只包含常量和方法的定义，没有方法的实现 3：接口可以实现多重实现 4：接口中声明的属性默认为public static final，也只能是public static final 5：接口中只能定义抽象方法，默认为public，也只能是public 6：接口可以继承其他接口，并添加新的属性和抽象方法原文：http://blog.csdn.net/u013628152/article/details/43375923

编写高质量代码改善java程序的151个建议——[1-3]基础?亦是基础【代码】【图】

原创地址: http://www.cnblogs.com/Alandre/ (泥沙砖瓦浆木匠),需要转载的,保留下! Thanks The reasonable man adapts himself to the world;the unreasonable one persists in trying to adapt the world to himself. —萧伯纳相信自己看得懂就看得懂了,相信自己能写下去,我就开始写了.其实也简单—泥沙砖瓦浆木匠 Written In The FontToday , I am writing my java notes about <编写高质量代码改善java程序的151个...

黑马程序员——Java基础---多线程【代码】

黑马程序员——Java基础<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ------ 一、概述　　对于Java而言，可以在一个程序中并发地启动多个线程，让这些线程在多处理器上同时运行。在单处理器系统中，多个线程共享CPU时间称为时间共享，而操作系统负责调度及分配资源给它们，即使是单处理器，多线程程序的运行速度也比单线程程序更快。当程序作...

java基础知识回顾之java Thread类学习（九）--wait和notify区别【代码】

wait和sleep区别：相同点：调用wait,sleep方法都可以是线程进入阻塞状态，让出cpu的执行权。不同点：1.sleep必须指定时间，但是wait方法可以指定时间，也可以不指定时间。 2.wait方法必须在同步中使用，但是sleep不一定在同步中使用。 3.在同步中，调用sleep方法释放CPU执行权，但是不会释放锁，即使让出了CPU执行权，其它线程也无法进入同步锁，不能得到执行。但是wait　　　　　　方法不...

Java基础：变量与常量【代码】【图】

变量变量相关介绍变量是什么：就是可以变化的量Java是一种强类型语言，每个变量都必须声明其类型Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域注意事项：每个变量都有类型，类型可以是基本类型，也可以是引用类型变量名必须是合法的标识符变量声明是一条完整的语句，因此每一个声明都必须以分号结束代码示例int a; int b; int c; //a,b,c变量的声明，也可以写在一行用逗号隔开，但是不建议这样写，会影响...

java-基础-【三】try/catch/finally【代码】

原文地址：https://my.oschina.net/bieber/blog/703251一、单层的try/catchpublicint test(int a,int b){try{return a+b;}catch (Exception e){thrownew CustomException();} }通过javap -v查看JVM编译成class字节码之后是如何处理这个try/catch的publicint test(int, int);flags: ACC_PUBLICCode:stack=2, locals=4, args_size=30: iload_1 // 将第一个int参数压入队列（第一个入参）1: iload_2 ...

基于C++基础对比性学习JAVA笔记【代码】

基于C++基础对比性学习JAVA笔记JAVA万物皆对象类名和文件名必须一致，且区分大小写java中所有的函数都必须写在类中创建对象的写法：Main main = new Main() ;System.out.print("helloworld");相当于printfSystem.out.println("helloworld");相当于printf+自动换行获取输入的写法，相当于scanf// 创建一个对象，接收输入流Scanner scanner = new Scanner(System.in);// 从对象中获取输入的信息//String str = scanner.next();int nu...

javase基础9【代码】【图】

1.面向对象的概念使用类映射现实生活中的事务,其功能封装为方法,属性封装为成员变量. 一个类拥有的成员包括:成员变量,构造方法,普通方法,getters/setters如一个person类:class Person{private String name;privateint age;public Person(){}public Person(String name,int age) {this.name = name;this.age = age; }publicvoid showName() {System.out.println(this.name);}set/get方法 }2.对象的内存解释对象在内存中的位置:对象...

Java 如何搭稳基础？【图】

这个问题对于学习了JAVA的学员们或者从事这方面工作的人来说，是个入行的问题。所以我们要重视这个问题。大部分学习java的人都把基础的知识给忽略掉了，其实基础的知识点尤为重要。怎么样才能夯实基础呢？我们可以从以下几个方面来讨论。一、掌握SE基础知识其实对于入门来说，首先是要找到学习java的感觉，如果我们刚开始学java时采用直接看书的形式，很多时候都是懵逼的，建议初学者第一次学java一定要尽量找线下面授的课程，或者...

Java基础知识强化08：将字符串倒序输出（包括空格）的几种方法【代码】【图】

1.最容易想到的估计就是利用String类的toCharArray（），再倒序输出数组的方法了： 1package himi.hebao05;2 3publicclass TestDemo02 {4publicstaticvoid main(String[] args) {5int i = 0;6 String text = "hebao I love you!";7 String result = " ";8char[] charArray = text.toCharArray();9for(int j = charArray.length-1; j>=0; j--) { 10 result += charArray[j]; 11 } 12 ...

java基础07【代码】【图】

二维数组二维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。例如,表示一个三行两列的数组：int a[3][2]=new int{{1,2},{2,3},{3,4}} 我们来拿一个例子遍历一下； public static void main(String[] args) {/** 1,2 a[0]* 2,3 a[1]* 3,4 a[2]* */int[][] a = {{1, 2}, {2, 3}, {3, 4}};for(int i=0;i<a.length;i++){//内部这个是遍历列的for(int j=0;j<a[i].length;j++){Sy...

java基础46 IO流技术（输入字符流/缓冲输入字符流）

一、输入字符流原创作者：DSHORE作者主页：http://www.cnblogs.com/dshore123/原文出自：https://www.cnblogs.com/dshore123/p/9272904.html欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）原文：https://www.cnblogs.com/dshore123/p/9272904.html

首页 / JAVA / 【Java并发】基础

【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)

内容总结

内容备注

内容手机端

【【Java并发】基础】教程文章相关的互联网学习教程文章

JAVA - 相关标签

并发 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程