一.线程概述

时间  2019-11-20
标签 线程 概述 繁體版
原文   原文链接

1.进程和线程的概念

进程：进程是操做系统结构的基础；是一次程序的执行；是一个程序及其数据在处理机上顺序执行时所发生的活动；是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位；进程是受操做系统管理的基本运行单元。java

线程：能够理解成是在进程中独立运行的子任务；使用多线程也就是在使用异步。线程分为两种一种是用户线程，一种是守护线程；守护线程是一种特殊的线程，当进程中不存在非守护线程了，则守护线程自动销毁（垃圾回收线程）,setDaemon(true)设置线程为守护线程。多线程

2.建立线程的方式

  • 继承Thread类
package chapter1.create;

public class MyThread extends Thread{
	
	@Override
	public void run() {
		super.run();
		System.out.println("MyThread");
	}

}

 

package chapter1.create;

public class Run {
    
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("end!");
    }

}

运行结果以下：异步

end!
MyThreadide

线程是一个子任务，CUP以不肯定的方式，或者说是随机的时间来调用线程中的run方法，因此就会出现先打印end!,再打印MyThread了。this

  • 实现Runnable接口
package chapter1.create;

public class MyRunnable implements Runnable{

	@Override
	public void run() {
		System.out.println("运行中...");
	}

}

 

package chapter1.create;

public class Run {
	
	public static void main(String[] args) {
		MyRunnable myRunnable = new MyRunnable();
		Thread thread = new Thread(myRunnable);
		thread.start();
		System.out.println("运行结束");
	}

}

 运行结果：spa

运行结束
运行中...
Thread.java类也实现了Runnable接口，也就意味着Thread(myRunnable)能够传入一个Thread类的对象，这样作能够将一个Thread对象中的run方法交由其余的线程进行调用。操作系统

使用继承Thread类的方式建立线程时，最大的局限就是不支持多继承。线程

3.经常使用方法介绍

  • currentThread()方法可返回代码段正在被哪一个线程调用的信息。
package chapter1.create;

public class MehthodCurrentThreadTest {
   
    static class CountOperate extends Thread{
        public CountOperate() {
            System.out.println("CountOperate init----begin");
            System.out.println("Thread.currentThread().getName()="+Thread.currentThread().getName());
            System.out.println("this.getName()="+this.getName());
            System.out.println("CountOperate init----end");
        }
        
        @Override
        public void run() {
            super.run();
            System.out.println("run----begin");
            System.out.println("Thread.currentThread().getName()="+Thread.currentThread().getName());
            System.out.println("this.getName()="+this.getName());
            System.out.println("run----end");
        }
    }
    
    public static void main(String[] args) {
        CountOperate countOperate = new CountOperate();
        Thread t = new Thread(countOperate);
        t.setName("A");
        t.start();
    }
}

运行结果：code

CountOperate init----begin
Thread.currentThread().getName()=main
this.getName()=Thread-0
CountOperate init----end
run----begin
Thread.currentThread().getName()=A
this.getName()=Thread-0
run----end对象

  • isAlive()判断当前的线程是否处于活动状态，活动状态就是线程已经启动且还没有终止。
  • sleep()是在指定的毫秒数内让当前"正在执行的线程"休眠(暂停执行)，这个"正在执行的线程"是指this.currentThread()返回的线程。
  • getId()取得线程的惟一标识。
  • yield()方法的做用是放弃当前的CPU资源，将它让给其余的任务去占用CPU执行时间。但放弃的时间不肯定，有可能刚刚放弃，立刻有得到CPU时间片。
  • suspend():暂停，已废弃。会有独占和不一样步的问题。
  • resume():恢复，已废弃；会有独占和不一样步的问题。

 4.中止线程

判断线程是否为中断状态的方法:

  • interrupted():当前线程是否已是中断状态，当前线程指运行interrupted()方法的线程,执行后具备将状态标志清除为false的功能;
    • public static boolean interrupted() {
            return currentThread().isInterrupted(true);
      }
  • isInterrupted():线程对象是否已是中断状态，但不清除状态标志。

中止线程的方法:

  • 使用interrupt方法中断线程，但方法并无中止线程，只是将状态标志为中断，调用isInterrupted()将返回true。
package chapter1.create.threadinterrupt;

public class MyThread extends Thread{
	
	@Override
	public void run() {
		super.run();
		for(int i=0;i<500000;i++) {
			System.out.println("i="+(i+1)+"interrupted------------"+this.isInterrupted());
		}
	}

}

 

package chapter1.create.threadinterrupt;

public class Run {
	
	public static void main(String[] args) {
		try {
			MyThread myThread = new MyThread();
			myThread.start();
			Thread.sleep(2000);
			myThread.interrupt();
		} catch (Exception e) {
			System.out.println("main catch.");
			e.printStackTrace();
		}
	}

}

 运行结果：

i=499992interrupted------------true
i=499993interrupted------------true
i=499994interrupted------------true
i=499995interrupted------------true
i=499996interrupted------------true
i=499997interrupted------------true
i=499998interrupted------------true
i=499999interrupted------------true
i=500000interrupted------------true

在沉睡中中止：

package chapter1.create.threadinterrupt;

public class StopWhenSleepTest {

static class MyThread extends Thread{
		
		@Override
		public void run() {
			super.run();
			try {
				System.out.println("run begin");
				Thread.sleep(200000);
				System.out.println("run end");
			} catch (InterruptedException e) {
				System.out.println("进MyThread.java类run方法中的catch了。"+this.isInterrupted());
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		try {
			MyThread myThread = new MyThread();
			myThread.start();
			Thread.sleep(2000);
			myThread.interrupt();
		} catch (Exception e) {
			System.out.println("main catch.");
			e.printStackTrace();
		}
		System.out.println("Main end");
	}
}

 运行结果：

run begin
Main end
进MyThread.java类run方法中的catch了。false
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at chapter1.create.threadinterrupt.StopWhenSleepTest$MyThread.run(StopWhenSleepTest.java:12)

若是在sleep状态下中止线程，会进入catch,而且清楚中止状态值，使之成为false。先interrupt再sleep也会进入catch,此处不作赘述。

  • 异常法
package chapter1.create.threadinterrupt;

public class StopThreadByExceptionTest {
	
	static class MyThread extends Thread{
		
		@Override
		public void run() {
			super.run();
			try {
				for(int i=0;i<500000;i++) {
					if(this.isInterrupted()) {
						System.out.println("已是中止状态了！我要退出了");
						throw new InterruptedException();
					}
					System.out.println("i="+(i+1));
				}
			} catch (InterruptedException e) {
				System.out.println("进MyThread.java类run方法中的catch了。");
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		try {
			MyThread myThread = new MyThread();
			myThread.start();
			Thread.sleep(2000);
			myThread.interrupt();
		} catch (Exception e) {
			System.out.println("main catch.");
			e.printStackTrace();
		}
	}

}

 运行结果：
i=420003
i=420004
i=420005
i=420006
i=420007
i=420008
i=420009
i=420010
i=420011
已是中止状态了！我要退出了
进MyThread.java类run方法中的catch了。
java.lang.InterruptedException
    at chapter1.create.threadinterrupt.StopThreadByExceptionTest$MyThread.run(StopThreadByExceptionTest.java:14)

  • 使用return中止线程:判断this.isInterrupted()为true,return。不过仍是建议使用“异常法”，由于在catch块中能够对异常的信息进行相关的处理，并且使用异常流能更好、更方便地控制程序的运行流程。
  • stop()暴力中止。该方法已经被废弃，由于若是强制让线程中止则有可能使一些清理性的工做得不到完成。另一个状况就是对锁定的对象“解锁”，致使数据得不到同步的处理，出现数据不一致的问题。

 5.线程的优先级

setPriority(int priority):值的范围1-10,设置线程优先级有助于帮“线程规划器”肯定在下一次选择哪个线程来优先执行。

  • 线程的优先级具备继承性，好比A线程启动B线程，则B线程的优先级与A是同样的。
  • 线程的优先级具备必定的规则性，也就是CPU尽可能将执行资源让个优先级较高的线程。
  • 线程的优先级具备随机性，也就是优先级较高的线程不必定每一次都先执行。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程