1.什么是线程
一个程序可以同时执行多个任务,每一个任务就称之为一个线程。
2.线程与进程
二者都是CPU时间段的一个描述,即某个线程或进程获得了CPU时间,进而执行其相应的任务。
线程存在于进程之中,一个进程至少包含一个线程。
每个进程都拥有自己的一整套变量,进程之间不共享,但线程则不是,它们会共享资源。
3.java中线程的创建与 启动
3.1 创建线程:
方式一:继承Thread类,但是不推荐使用这种方法定义线程,因为这使得线程任务和线程控制揉合在了一起。
//1.继承Thread类
//2.重写run方法,在run方法中定义线程所执行的逻辑,即如何去完成这个线程任务的逻辑。
public class MyThread extends Thread{
//构造方法,可以设置一些参数
public MyThread(){
}
//重写run方法
@Override
public void run() {
//线程要执行的逻辑:每隔一秒输入当前时间
while(true) {
try {
System.out.println(new Date());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
方式二:实现Runnable接口
//1.实现Runnable接口
//2.重写run方法,在run方法中实现业务逻辑
public class MyThread implements Runnable{
//构造方法,可以设置一些参数
public MyThread() {
}
@Override
public void run() {
while(true) {
try {
System.out.println(new Date());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
3.2 启动线程
//对继承Thread类定义的线程,直接调用该对象的start()。
public static void main(String[] args) {
MyThread t = new MyThread();//MyThread类继承自Thread类
t.start();
}
//对于实现Runnable接口而定义的线程类,则要将该线程对象作为参数传给Thread类对象,然后调用Thread类的start()方法。
public static void main(String[] args) {
MyRunnable r = new MyRunnable();//实现了Runnable接口
Thread t = new Thread(r);
t.start();
}
3.3 为什么启动线程要调用start()方法而不调用run()方法?看下面的例子。
public static void main(String[] args) {
MyRunnable r = new MyRunnable();//实现了Runnable接口,此类为上面的MyRunnable类。//1
Thread t = new Thread(r);//2
t.start();//3
System.out.println("线程执行了吗?");//4
}
//此时运行上面的代码,执行了语句3后程序不会阻塞,接着语句4会立马执行。
/*如果将语句3改为 t.run();则程序也会执行run方法中定义的循环,由于上面run方法中定义的是一个无限循环,
而语句4必须要等等语句3执行完成后方能执行,故此时语句4是永远不会被执行的。此时你可以将run方法中的循环定义
为一个有限循环,你会发现循环执行完了才会输出语句4.
由此可见,如果调用run方法,它只是被当作一个普通方法。
*/
3.4 练习:写一个程序,同时执行三个线程任务:输出字母a 100次,输出字母b 100次,输出1~100之间的整数。
4.线程的状态
4.1 线程的几种状态
- 新建状态:当我们new了一个Thread对象时,此时线程就处于新建状态。
- 可运行状态:当调用了start方法后,线程可能会马上执行,也可能不会。此时叫可运行状态。
- 运行状态:当线程抢到了CPU资源,此时线程就会执行,因此处于运行状态。
- 阻塞状态:将调用sleep,wait等方法后,线程仍是活的,但是它不具有可执行条件,而是需要等待某一事件的触发(如睡眠时间到了,notify方法等),才会回到可运行状态。
- 死亡状态:线程执行完了,就会进入死亡状态。
4.2 线程Thread类的相关方法
start:使线程开始执行,java虚拟机调用run方法,此时会有2个线程并发执行,当前线程(调用start方法并返回)和另一个线程(执行run方法),重复启动同一个线程会报错。
sleep:
static void sleep(long millis)让线程暂停指定毫秒数。
static void sleep(long millis, int nanos)让线程暂停指定的毫秒数加纳秒数。nanos值 为0~999999。
该方法线程不会释放它所持有的锁。
sleep方法可以会抛出InterruptedException , 这是一个必检异常。所以要将其放在try-catch块中执行,注意,当在一个循环中调用sleep方法时,要将整个循环放入try-catch块中,而不能将try-catch块放在循环中(这样的话线程发生异常后也还会继续执行)。try { while(.....) { Thread.sleep(1000); } } catch (InterruptedException e) { //当前线程被其它线程中断时发生 e.printStackTrace(); }
yeild:
static void yeild()
暂停执行当前线程,但此时它不是处于阻塞状态,而是处于可执行状态,它仍会参与争夺CPU时间。activeCount :
static int activeCount()
返回当前线程组中活的线程数量。Thread.activeCount();currentThread
static Thread currentThread()
返回当前执行的线程。Thread.currentThread();getState
Thread.state getState() 返回线程状态,只用于监视系统状态。
NEW:创建后从未启动的线程。
RUNNABLE:可运行行的线程。
BLOCKED:受阻塞并等待某个监视器锁的线程。
WAITING:无限期等待另一个线程来执行某一特定操作的线程。
TIME WAITING:计时等待的线程。
TERMINATED:已退出的线程。- interrupt
void interrupt()
向线程发送中断请求,此时线程的中断状态会被改为true.如果此时线程被一个sleep方法阻塞,会抛出InterruptException异常。 - interrupted
static boolean interrupted()
检查当前线程是否已经中断,它会将当前线程的中断状态由true重置为false。 - isInterrupted
检查当前线程是否已经中断,它不会像上面方法那样重置线程的中断状态。
public class MyRunnable1 implements Runnable{
private String name;
private int num;
public MyRunnable1(String name,int num) {
this.name = name;
this.num = num;
}
public void run() {
while(num < 100) {
System.out.println(name + ":" + num);
num++;
if(num == 80) {
Thread.currentThread().interrupt();
System.out.println(num + ":"+Thread.currentThread().isInterrupted());//ture
}
if(Thread.interrupted()) {//当num=80时其本身会返回true,但它会将当前线程中断状态改为false。
System.out.println(num + ":"+Thread.currentThread().isInterrupted());//false
}
System.out.println(Thread.currentThread().isInterrupted());
}
}
}
- join
void join() 主线程等待该线程(调用join方法的线程)执行完了再继执行。
void join(long millis) 当millis为0,则意味着一直等下去,直到线程执行完成。
void join(long millis,int nanus) nanus的值为0~999999
//线程类
public class MyRunnable implements Runnable{
private int i;
public MyRunnable(int i) {
this.i = i;
}
@Override
public void run() {
while(i < 10) {
System.out.println(i);
i++;
try {
Thread.sleep(100);//睡眠100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//在一个测试类的main方法中调用这个线程
public class ThreadTest {
public static void main(String[] args) {
MyRunnable r = new MyRunnable(0);
Thread t = new Thread(r);
t.start();
try {
t.join();//语句1
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程执行完了");//语句2
}
}
/*
此时运行的结果是先输出线程中的循环,最后输出语句2,如果将语句1(try-catch块)注释掉,此时的执行结果先输出语句2,再输入线程中的循环。这说明当线程t调用了join方法后,main主线程会等待线程t执行完了再继续往下执行。你还可以在join方法中传入时间参数,如500,观察运行结果的变化。
*/
- isDaemon
final boolean isDaemon() 判断该线程是否是一个守护线程。 - setDaemon
final void setDaemon(boolean on)标记该线程为守护线程(true)或用户线程(false).当正在运行的线程都是守护线程时,JVM退出。守护线程是为其他线程提供服务的,所以可能会在任何时候中断(因为只要其他线程都执行完成了,就只会剩下守护线程在执行,此时JVM就会自动退出),因此守护线程永远不要去访问资源(文件,数据库)。另外这一方法必须在启动线程之前调用。GC就是一个经典的守护线程。
//守护线程,这是一个无限循环
public class DaemonThread implements Runnable {
@Override
public void run() {
while (true) {
System.out.println(new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//用户线程,输入10次
public class UserThread implements Runnable {
@Override
public void run() {
int i = 0;
while (i < 10) {
System.out.println("User Thread:" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
}
}
}
//测试
public class ThreadTest {
public static void main(String[] args) {
DaemonThread daemon = new DaemonThread();//守护线程
UserThread user = new UserThread();//用户线程
Thread d = new Thread(daemon);
d.setDaemon(true);//设为守护线程,语句1
Thread u = new Thread(user);
d.start();
u.start();
}
}
//运行会发现用用户线程执行完成后,程序就退出执行了。如果此时将语句1的参数改为false,则会一直进行下去。
- setName
void setName(String name) 设置线程名称 - setPriority
void setPriority(int newPriority) 设置优先级,线程默认会继承生成它的线程的优先级。 - -