Java中线程的使用 (2)-多线程、线程优先级、线程睡眠、让步、阻塞

（一）多线程使用方法

说明：创建每个新的线程，一定要记得启动每个新的线程（调用.start()方法）

class Xc3 extends Thread

{

public void run()

{

System.out.println( Thread.currentThread().getName()+"在执行");

} //显示当前线程名称

}

public class L6_3

{

public static void main(String[] args)

{

Xc3 xc31=new Xc3();

xc31.setName("线程1");

xc31.start();

Xc3 xc32=new Xc3();

xc32.setName("线程2");

xc32.start();

Xc3 xc33=new Xc3();

xc33.setName("线程3");

xc33.start();

System.out.println( Thread.currentThread().getName()+"在执行");

}

（二）设置线程的优先级

说明：你想要提高优先级的线程调用setPriority方法即可，例如线程2 提高优先级的事例如下：xc2.setPriority(Thread.NORM_PRIORITY + 3);。3表示增加的优先级，数字越大，优先级越大。

public class L6_4 {

public static void main(String[] args)

{

Thread xc1 = new Thread(new Xc41());

Thread xc2 = new Thread(new Xc42());//线程默认级别是5

xc2.setPriority(Thread.NORM_PRIORITY + 3); //数字越大优先级越高

xc1.start();

xc2.start();

}

class Xc41 implements Runnable {

public void run() {

for(int i=0; i<100; i++) {

System.out.println("1线程" + i);

}

class Xc42 implements Runnable {

public void run() {

for(int i=0; i<100; i++) {

System.out.println("第2个线程正在被执行: " + i);

}

（三）线程睡眠

说明：3点

1. 想要线程睡眠直接调用sleep函数即可，这个sleep是个静态函数，所以可以用类名调用。2.本例的示例：Thread.sleep(1000); //1000毫秒等于1秒。其实也就这一句话。

3.后面的线程让步，线程阻塞，和开始的线程，其实也就是类似这样的一句话。

public class L6_5

{

public static void main(String[] args)

{

Xc5 xc5 = new Xc5();

Thread ccc = new Thread(xc5);

ccc.start();

}

class Xc5 implements Runnable

{

public void run() //throws Exception

{

for (int i=0; i<10; i++)

{

System.out.println(Thread.currentThread().getName() + " " + i);

try

{

Thread.sleep(1000); //1000毫秒等于1秒

}

catch (Exception e)

{

}

（四）进程让步

说明：

核心代码：Thread.yield();

代码：

public class L6_6

{

public static void main(String[] args)

{

Xc6 xc6 = new Xc6();

Thread aa = new Thread(xc6);

Thread bb = new Thread(xc6);

aa.setName("线程一");

bb.setName("线程二");

aa.start();

bb.start();

}

class Xc6 implements Runnable

{

public void run()

{

for(int i=1;i<=30;i++)

{

System.out.println(Thread.currentThread().getName()+": "+i);

if(i%5==0)

{

Thread.yield();

}

运行结果：

线程一: 1

线程二: 1

线程一: 2

线程二: 2

线程一: 3

线程二: 3

线程一: 4

线程二: 4

线程一: 5

线程二: 5

线程一: 6

线程二: 6

线程一: 7

线程二: 7

线程一: 8

线程二: 8

线程一: 9

线程二: 9

线程一: 10

线程二: 10

线程二: 11

线程一: 11

线程二: 12

线程一: 12

线程二: 13

线程一: 13

线程二: 14

线程二: 15

线程一: 14

线程二: 16

线程一: 15

线程二: 17

线程一: 16

线程二: 18

线程一: 17

线程二: 19

线程二: 20

线程二: 21

线程二: 22

线程二: 23

线程二: 24

线程二: 25

线程二: 26

线程二: 27

线程二: 28

线程二: 29

线程二: 30

线程一: 18

线程一: 19

线程一: 20

线程一: 21

线程一: 22

线程一: 23

线程一: 24

线程一: 25

线程一: 26

线程一: 27

线程一: 28

线程一: 29

线程一: 30

结果说明：

在结果中可以发现线程一在5,10,15的时候都让给线程二执行了，20,25,30的时候无人可让，所以就接着自己执行。

（五）进程阻塞

说明：

阻塞时将当前线程暂停，直至调用join函数所对应的线程执行完毕，才继续执行程序。
核心代码：dd.join();//dd是线程名字

代码：

public class L6_7

{

public static void main(String args[])

{

Xc7 xc7=new Xc7();

Thread dd = new Thread(xc7);

dd.start();

try{

dd.join(); //阻塞时将当前线程暂停，直至调用join函数所对应的线程执行完毕，才继续执行程序。

}

catch(Exception e)

{

}

for(int i=0;i<15;i++){

System.out.println("主线程:" + i);

}

class Xc7 implements Runnable {

public void run() {

for(int i=0;i<10;i++) {

System.out.println("子线程: " + i);

}

结果：

子线程: 0

子线程: 1

子线程: 2

子线程: 3

子线程: 4

子线程: 5

子线程: 6

子线程: 7

子线程: 8

子线程: 9

主线程:0

主线程:1

主线程:2

主线程:3

主线程:4

主线程:5

主线程:6

主线程:7

主线程:8

主线程:9

主线程:10

主线程:11

主线程:12

主线程:13

主线程:14

结果说明：

子线程执行完了才是主线程。