【TX】前言：JAVA是少数的几种支持多线程的语言之一，它可以让不同的程序块同时运行，从而使程序更为顺畅，性能也更高，同时也达到了多任务处理的目的。
一：进程和线程概念
1：【进程】是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整过程，这个过程也是进程本身送产生，发展到最终消亡的过程。多进程系统能同时运行过个进程【程序】。由于CPU具备分时机制，所以每个进程都能循环获取到自己的CPU时间片。由于CPU的运行速度很快，所以使得所有程序好像是在“同时”运行一样。
2：【线程】是比进程更小的执行单位，是在进程基础上的进一步划分。多线程是指一个进程在执行的过程中可以产生多个更小的程序单元，这些更小的程序单位称为线程，这些线程可以同时存在，同时运行，多线程是实现并发机制的一种有效手段。
二：多线程的实现：继承Thread类；实现Runnable接口
例1：继承Thread类
package com.tmx.Threads;
public class ThreadTest1 extends Thread{
private String name;
public ThreadTest1(String name) {
super();
this.name = name;
}
@Override
public void run(){ //------------------run()方法用于定义线程的主体
for (int i = 0; i < 3; i++) {
System.out.println(name+"执行,i="+i);
}
}
public static void main(String[] args) {
ThreadTest1 thr1=new ThreadTest1("线程A");
ThreadTest1 thr2=new ThreadTest1("线程B");
thr1.start();//------------------start()方法用于启动线程
thr2.start();
}
}例1程序的执行结果：
线程B执行,i=0
线程A执行,i=0
线程A执行,i=1
线程A执行,i=2
线程B执行,i=1
线程B执行,i=2这里需要注意的是，run()方法只是定义线程的主体，而启动线程则需要调用start()方法。
例2：实现Runnable接口
需要注意的是Runnable接口中只定义了一个方法，就是run()方法，所以启动线程就需要依靠Thread类的start()方法。
public class RunnableTest1 implements Runnable{
private String name;
public RunnableTest1(String name) {
super();
this.name = name;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(name+"执行,i="+i);
}
}
public static void main(String[] args) {
RunnableTest1 rnb1=new RunnableTest1("线程A");
RunnableTest1 rnb2=new RunnableTest1("线程B");
Thread thread1 = new Thread(rnb1);
Thread thread2 = new Thread(rnb2);
thread1.start();
thread2.start();
}
}例2执行结果：
线程A执行,i=0
线程A执行,i=1
线程A执行,i=2
线程B执行,i=0
线程B执行,i=1
线程B执行,i=2看见这个结果，可能我们会以为这并不是多线程，因为看起来是按顺序执行的。而实际上，这仍然是多线程执行，因为两个线程对象是交错运行的，谁抢到了CPU资源，谁就先运行，所以每次运行的结果也是不同的。
三：Thread类和Runnable接口的区别和联系
1：两者的联系
public class Thread implements Runnable从Thread类的定义我们可以清楚地发现，Thread类也是Runnanble接口的子类。我们继续看Thread类的部分定义：
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null);
}
@Override
public void run() {
if (target != null) {
target.run();
}
}从Thread类的定义中可见，run方法调用的是Runnable接口中的run方法，所以如果要通过继承Thread类实现多线程，则必须复写run方法。
2：两者的区别
实现Runnable接口相对于继承Thread类的优势
(a) 适合多个相同程序代码的线程去处理同一资源的情况
(b)可以避免由于JAVA单继承特性带来的局限
(c)增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的
Thread类并不适合多个线程共享资源：
例3：继承Thread类
package com.tmx.Threads;
public class ThreadTest1 extends Thread{
private String name;
private int ticket=3;
public ThreadTest1(String name) {
super();
this.name = name;
}
@Override
public void run(){
for (int i = 0; i < 10; i++) {
if(ticket>0){
System.out.println(name+"卖票：ticket="+ticket--);
}
}
}
public static void main(String[] args) {
ThreadTest1 thr1=new ThreadTest1("售票员A");
ThreadTest1 thr2=new ThreadTest1("售票员B");
thr1.start();
thr2.start();
}
}例3运行结果：
售票员B卖票：ticket=3
售票员A卖票：ticket=3
售票员B卖票：ticket=2
售票员A卖票：ticket=2
售票员B卖票：ticket=1
售票员A卖票：ticket=1可见，继承Thread类，只起到了多线程执行的作用，并没有起到资源共享的效果。
例4：实现Runnable接口
package com.tmx.Threads;
public class RunnableTest1 implements Runnable{
private String name;
private int ticket=3;
public RunnableTest1(String name) {
super();
this.name = name;
}
@Override
public void run(){
for (int i = 0; i < 10; i++) {
if(ticket>0){
System.out.println(name+"卖票：ticket="+ticket--);
}
}
}
public static void main(String[] args) {
RunnableTest1 rnb1=new RunnableTest1("售票员");
Thread thread1 = new Thread(rnb1);
Thread thread2 = new Thread(rnb1);
Thread thread3 = new Thread(rnb1);
thread1.start();
thread2.start();
thread3.start();
}
}例4运行结果：
售票员卖票：ticket=3
售票员卖票：ticket=1
售票员卖票：ticket=2此处一定要注意这两者启动多个线程的方式是不一样的，而且要观察例4的运行结果顺序。所以在实际开发中应尽量实现Runnable接口。
四：线程的状态
任何线程一般都5中状态，即：创建，就绪，运行，阻塞，死亡。
1：创建状态
线程的创建通过Thread类的构造方法来实现：
Thread thread = new Thread();
Thread thread = new Thread(Runnable target);
线程创建后它即有了相应的内存空间和其他资源，但此时它是不可运行的
2：就绪状态
调用start()方法可以启动线程，此时线程处于就绪状态，等待CPU服务，表名它已经具备了运行的条件
3：当就绪状态获得处理器资源是，线程被调用进入了运行状态，此时，自动调用改线程对象的run()方法。run方法定义了线程的操作和功能。
4：堵塞状态
在可执行状态下，调用sleep(),suspend(),wait()方法都会时线程进入阻塞状态，堵塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。
5：死亡状态
线程调用stop()方法或者run()方法执行结束后，即处于死亡状态，死亡状态的线程不具有继续运行的能力。
从线程状态可以看出，run()方法只是定义线程的主体功能，而start()方法才能启动线程。
五：线程的常用方法
Runnable接口中只有一个run()方法，所以线程的操作方法基本都在Thread类中。
1：线程的构造方法
Thread thread = new Thread(String name);
Thread thread = new Thread(Runnable target);
Thread thread = new Thread(String name,Runnable target);线程主要有三个常见构造方法，其中String参数用于设置线程名称
例1：设置及获取当前线程的名称
public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 0; i < 2; i++) {
String name2 = Thread.currentThread().getName();
System.out.println(name2);
}
}
public static void main(String[] args) {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1);
Thread thread2 = new Thread(rnb1);
Thread thread3 = new Thread(rnb1,"线程A");
thread1.start();
thread3.start();
thread2.start();
}
}例1运行结果：
Thread-0
Thread-0
线程A
线程A
Thread-1
Thread-1可见当没有为一个线程指定一个明确的名称时，系统在使用时会为线程分配一个名称，默认格式为Thread-Xx
例1_1：主方法线程
public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 0; i < 2; i++) {
String name2 = Thread.currentThread().getName();
System.out.println("当前线程名称为:"+name2);
}
}
public static void main(String[] args) {
RunnableTest1 rnb1=new RunnableTest1();
rnb1.run();
Thread thread1 = new Thread(rnb1,"线程A");
thread1.start();
}
}例1_1运行结果：
当前线程名称为:main
当前线程名称为:main
当前线程名称为:线程A
当前线程名称为:线程A由例2可见主方法也是一个线程。在JAVA中所有线程都是同时启动的，哪个线程先抢到了CPU资源，那个线程就先运行。
java在运行时至少会启动两个线程，一个是main线程，另一个是垃圾收集线程
例1_2：
public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 1; i <= 2; i++) {
String name1 = Thread.currentThread().getName();
System.out.println(name1+"线程运行:"+name1);
System.out.println(name1+"线程运行:"+name1);
}
}
public static void main(String[] args) throws InterruptedException {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
Thread thread2 = new Thread(rnb1,"线程B");
thread1.start();
thread2.start();
}
}例1_2运行结果：
线程A线程运行:线程A
线程B线程运行:线程B
线程A线程运行:线程A
线程A线程运行:线程A
线程B线程运行:线程B
线程B线程运行:线程B
线程B线程运行:线程B
线程A线程运行:线程A例2：isAlive()判断线程是否启动
public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 0; i < 2; i++) {
String name2 = Thread.currentThread().getName();
System.out.println("当前线程名称为:"+name2);
}
}
public static void main(String[] args) {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
System.out.println("未执行start方法前,线程是否启动:"+thread1.isAlive());
thread1.start();
System.out.println("执行start方法后,线程是否启动:"+thread1.isAlive());
for (int i = 0; i < 2; i++) {
System.out.println("main方法执行:"+i);
}
System.out.println("执行main方法后,线程是否启动:"+thread1.isAlive());
}
}例2运行结果1：
未执行start方法前,线程是否启动:false
执行start方法后,线程是否启动:true
main方法执行:0
当前线程名称为:线程A
main方法执行:1
当前线程名称为:线程A
执行main方法后,线程是否启动:true例2运行结果2：
未执行start方法前,线程是否启动:false
执行start方法后,线程是否启动:true
main方法执行:0
当前线程名称为:线程A
当前线程名称为:线程A
main方法执行:1
执行main方法后,线程是否启动:false从这两个结果我们可以发现：
main方法是一个线程；
线程是否存活，要看谁先执行结束。
例3：线程的强制执行 join()方法
使用join()方法可以让一个线程强制执行，在执行期间，其他线程无法运行，必须等待此线程结束后才可以继续执行
public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 1; i <= 5; i++) {
String name2 = Thread.currentThread().getName();
System.out.println(name2+"线程运行:"+i);
}
}
public static void main(String[] args) throws InterruptedException {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
thread1.start();
for (int i = 1; i <= 5; i++) {
if(i>3){
thread1.join();
}
System.out.println("main线程运行："+i);
}
}
}例3执行结果：
main线程运行：1
main线程运行：2
线程A线程运行:1
main线程运行：3
线程A线程运行:2
线程A线程运行:3
线程A线程运行:4
线程A线程运行:5
main线程运行：4
main线程运行：5例4：线程的休眠：sleep()
线程休眠直接调用sleep()方法即可，这是一个Static关键字修饰的方法
public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 1; i <= 2; i++) {
try {
Thread.sleep(2000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name1 = Thread.currentThread().getName();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(new Date());
System.out.println(name1+"线程运行时间:"+format);
}
}
public static void main(String[] args) throws InterruptedException {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
thread1.start();
}
}例4运行结果：
线程A线程运行时间:2018-03-11 16:12:31
线程A线程运行时间:2018-03-11 16:12:33例5：线程的终止：interrupt()方法
public class RunnableTest1 implements Runnable{
@Override
public void run(){
System.out.println("1:进入run方法");
try {
Thread.sleep(2000L);
System.out.println("2:休眠2s已结束");
} catch (InterruptedException e) {
System.out.println("3:休眠被终止,抛出异常:"+e);
return;
}
System.out.println("4:run方法结束");
}
public static void main(String[] args) throws InterruptedException {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
thread1.start();
Thread.sleep(1000L);
thread1.interrupt();
}
}例5运行结果：
1:进入run方法
3:休眠被终止,抛出异常:java.lang.InterruptedException: sleep interrupted
由于线程休眠期间，主方法将线程中断，休眠一旦中断之后将执行catch中的内容，由于使用了return，所以"4:run方法结束"语句并没有执行。
例6：后台线程
在JAVA中，只要前台有一个线程在运行，则整个JAVA进程都不会消失，所以此时可以设置一个后台线程，这样即使java进程结束了，此后台线程依然会继续执行。此时就需要使用setDaemon()方法
public class RunnableTest1 implements Runnable{
@Override
public void run(){
while(true){
String name2 = Thread.currentThread().getName();
System.out.println(name2+"线程运行");
}
}
public static void main(String[] args) throws InterruptedException {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
thread1.setDaemon(true);
thread1.start();
// System.out.println("main线程运行");
}
}例6运行结果：
线程A线程运行需要注意的是，程序也可能什么也不打印，但不会出现死循环，因为死循环线程操作已经被设置成后台运行了。
例7：线程的优先级
Java线程优先级有三种，他们都是常量
public static final int MIN_PRIORITY;//------最低优先级，常量为1
public static final int NORM_PRIORITY;//-----默认中等优先级，常量为5
public static final int MAX_PRIORITY;//------最高优先级，常量为10public class RunnableTest1 implements Runnable{
@Override
public void run(){
for (int i = 0; i < 3; i++) {
String name = Thread.currentThread().getName();
System.out.println(name+"线程运行");
}
}
public static void main(String[] args) throws InterruptedException {
RunnableTest1 rnb1=new RunnableTest1();
Thread thread1 = new Thread(rnb1,"线程A");
Thread thread2 = new Thread(rnb1,"线程B");
Thread thread3 = new Thread(rnb1,"线程C");
thread1.setPriority(Thread.MAX_PRIORITY);//thread1.setPriority(10)
thread2.setPriority(Thread.NORM_PRIORITY);//thread1.setPriority(5)
thread3.setPriority(Thread.MIN_PRIORITY);//thread1.setPriority(1)
thread1.start();
thread2.start();
thread3.start();
}
}例7运行结果1：
线程A线程运行
线程A线程运行
线程A线程运行
线程B线程运行
线程B线程运行
线程B线程运行
线程C线程运行
线程C线程运行
线程C线程运行例7运行结果2：
线程B线程运行
线程C线程运行
线程C线程运行
线程C线程运行
线程A线程运行
线程A线程运行
线程B线程运行
线程A线程运行
线程B线程运行由结果可见，并非线程的优先级越高，此线程就一定会优先执行，哪个线程先执行将有CPU的调度决定。其特点为：
主方法main的优先级为5
线程基础就先到这里。
6290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
