java 线程分组执行_Java多线程

一、进程和线程

进程：是程序的一次动态执行的过程。它对应了从代码加载、执行至执行完毕的一个完整过程。这个过程也是进程本身从产生、发展至消亡的过程。

线程：是比进程更小的执行单位。一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程，也有它自身的产生、存在和消亡的过程。

二、单线程和多线程

单线程：即一个程序只有一条从头到尾的执行线索。

多线程：是指同时存在几个执行体，按几条不同的执行线索共同工作的情况。

三、线程的状态和生命周期

线程的4个状态：

1> New(新生)

新生的线程对象处于新建状态，此时他已经有了相应的内存空间和其他资源。

2> Runnable(可运行)

线程创建之后就具备了运行的条件，一旦轮到它来享用CPU资源时，就脱离了创建它的主线程，独立开始自己的生命周期了。

3> Blocked(被阻塞)

被阻塞的原因： 当前线程让出CPU的使用；执行了sleep()方法；执行了wait()方法；执行某个操作进入了阻塞状态。

4> Dead(死亡)

处于死亡状态的线程不具有继续运行的能力。线程死亡的原因有二个：一个是正常运行的线程完成了它的全部工作；另一个原因是线程被提前强制性终止。

四、线程的优先级

每个Java线程的优先级都在常数：1~10之间，即Thread.MIN_PRIORITY和Thread.MAX_PRIORITY之间。如果没有明确的设置线程的优先级别，每个线程的优先级都是常数：5，即：Thread.NORM_PRIORITY。

线程的优先级可以通过setPriority(int grade)方法调用。

getPriority()方法返回线程的优先级。

有些操作系统只能识别3个级别：1、5、10 。

五、守护线程和非守护线程

非守护线程： 线程默认就是非守护线程。

守护线程：调用setDaemon(true)可以将一个线程设置成守护(Daemon)线程。当程序的所有非守护线程都已结束运行时，即使守护线程的run()方法中还有需要执行的语句，守护线程也立刻结束运行。

六、线程组

Java程序语言允许创建线程组，线程组就是把行为相似的线程分为一个组。

String groupName = “GroupName”;

ThreadGroup g = new ThreadGroup(groupName);

ThreadGroup构造器中的字符接串参数是用来标识该组的，它必须是唯一的。

Thread t = new Thread(g,threadName);

七、线程的执行

调用了start()方法的线程，就处于就绪队列排队的线程，一旦轮到它来享用CUP时，就可以脱离创建它的线程独立开始生命周期了。处于就绪排队的线程，并不一定先调用start()方法的线程，就先执行，而是取决于当前CUP的执行的资源。

线程的优先级越高，获得使用CUP资源的机会越高，但是并不一定是级别高的线程就一定先获得CUP，而是取决于当前CUP的执行的资源。

每个执行的线程都拥有自己单独的栈内存。

八、线程的API

1.构造方法

Thread()

Thread(String name)

Thread(ThreadGroup group, String name)

Thread(Runnable target)

Thread(Runnable target, String name)

Thread(ThreadGroup group, Runnable target)

Thread(ThreadGroup group, Runnable target, String name)

Thread(ThreadGroup group, Runnable target, String name, long stackSize)

2.实例方法

start();

启动线程，使从新建状态进入就绪队列排队，一旦轮到它来享用CPU资源时，就可以脱离创建它的线程独立开始自己的生命周期了。

sleep();

在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行)，此操作受到系统计时器和调度程序精度和准确性的影响。

isAlive();

线程处于新建时，返回false;线程在执行run方法结束之前，没有进入死亡状态之前，返回true;

interrupt();

用来唤醒休眠的线程。当一个线程处于休眠状态时，一个占有CPU资源的线程可以让休眠的线程调用interrupt()方法吵醒自己，即导致休眠的线程发生InterruptedException异常，从而结束休眠，重新排队等待CPU资源。

3.静态方法

Thread.sleep();

当前线程进入休眠状态；

Thread.currentThread();

返回当前正在执行的线程；

Thread.isInterrupted();

返回当前正在执行的线程是否被打断；

package com.what21.thread01;

public class ThreadTest01 {

/**

* @param args

*/

public static void main(String[] args) {

ThreadA a = new ThreadA();

a.start();

//================================//

ThreadA a2 = new ThreadA();

a2.setName("我是线程");

// 最低优先级

a2.setPriority(Thread.MIN_PRIORITY);

a2.start();

//================================//

ThreadA a3 = new ThreadA();

a3.setName("我是守护线程");

// 守护线程

a3.setDaemon(true);

// 最高优先级

a3.setPriority(Thread.MAX_PRIORITY);

a3.start();

}

}

class ThreadA extends Thread{

@Override

public void run() {

System.out.print("ThreadID: " + this.getId() + " ");

System.out.print("ThreadName: " + this.getName() + " ");

System.out.println();

try {

Thread.sleep(10 * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

package com.what21.thread01;

public class ThreadTest02 {

/**

* @param args

*/

public static void main(String[] args) {

Thread b = new Thread(new ThreadB());

b.start();

//================================//

Thread b2 = new Thread(new ThreadB());

b2.setName("我是线程");

// 最低优先级

b2.setPriority(Thread.MIN_PRIORITY);

b2.start();

//================================//

Thread b3 = new Thread(new ThreadB());

b3.setName("我是守护线程");

// 守护线程

b3.setDaemon(true);

// 最高优先级

b3.setPriority(Thread.MAX_PRIORITY);

b3.start();

}

}

class ThreadB implements Runnable{

public void run() {

System.out.print("ThreadID: " + Thread.currentThread().getId() + " ");

System.out.print("ThreadName: " + Thread.currentThread().getName() + " ");

System.out.println();

try {

Thread.sleep(10 * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

package com.what21.thread01;

public class ThreadTest03 {

public static Thread t, t2, t3;

/**

* @param args

*/

public static void main(String[] args) {

t = new Thread(new ThreadC());

t.setName("thread1");

t.start();

t2 = new Thread(new ThreadC());

t2.setName("thread2");

t2.start();

t3 = new Thread(new ThreadC());

t3.setName("thread3");

t3.start();

}

}

class ThreadC implements Runnable {

public void run() {

Thread exeT = Thread.currentThread();

if (exeT.isAlive()) {

if (exeT == ThreadTest03.t) {

for (int i = 1; i < 3; i++) {

System.out.println(exeT.getName() + " 正在执行 " + i + " 次.");

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

System.out.println(exeT.getName() + " 被打断 ... ");

}

}

} else if ("thread2".equals(exeT.getName())) {

for (int i = 1; i < 3; i++) {

System.out.println(exeT.getName() + " 正在执行 " + i + " 次.");

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

System.out.println(exeT.getName() + " 被打断 ... ");

}

}

} else if ("thread3".equals(exeT.getName())) {

for (int i = 1; i < 7; i++) {

System.out.println(exeT.getName() + " 正在执行 " + i + " 次.");

if (ThreadTest03.t.isAlive()) {

ThreadTest03.t.interrupt();

}

if (ThreadTest03.t2.isAlive()) {

ThreadTest03.t2.interrupt();

}

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

}

}