Java学习笔记——线程

进程

进程就是一个运行的程序，Windows操作系统是支持多进程的操作系统，即同一时间可以执行多个程序，每个程序是在自己独立的内存空间内，使用自己被分配到的系统资源。其实，这种说法并不准确，一个CPU在某个时刻，实际上只能运行一个程序，即一个进程。所谓的支持多进程，其实就是CPU在交替轮流执行多个程序，例如，利用Windows操作系统可以一边听歌曲、一边上网等。

线程

线程是运行程序（进程）中单个顺序的小程序，一个进程可以由多个线程组成，而这多个线程共享同一个存储空间，这使得线程间的通信比较容易。

线程的创建——Runnable接口

Runnable接口的定义：

public interface Runnable
{
public abstract void run（）；
}

创建线程的结构如下：

Thread t=new Thread（runnable对象）；

实例：

01 ///创建两个线程，让其交替运行
02 public class threadtest
03 {
04 public static void main（String[]args）
05 {
06 compute c=new compute（）；
07 compute1 c1=new compute1（）；
08 Thread t=new Thread（c）；
09 Thread t1=new Thread（c1）；
10 t.start（）；
11 t1.start（）；
12 }
13 }
14 ///这是一个线程类
15 ///这个类主要是用来通过循环语句输出数字
16 class compute implements Runnable
17 {
18 int i=0；
19 public void run（）
20 {
21 for（int i=0；i＜10；i++）
22 {
23 System.out.println（i）；
24 }
25 }
26 }
27 ///这是一个线程类
28 ///这个类主要是用来通过循环语句输出字符串语句
29 class compute1 implements Runnable
30 {
31 public void run（）
32 {
33 for（int i=0；i＜10；i++）
34 {
35 System.out.println（"这个数字是："+i）；
36 }
37 }
38 }

这个程序段中，创建了两个线程，不过读者多次运行后可能结果会有不同。因为在程序中存在一个执行问题。在Java技术中，线程通常是抢占式的，其不需要时间片的分配。抢占式调度模式指许多线程处于可以运行状态，即等待状态，但实际只有一个线程在运行。该线程一直运行到它终止，或者另一个具有更高优先级变成可运行状态。在后一种情况下，低优先级线程被高优先级线程抢占且获得运行机会。

线程的创建——继承Thread类

01 ///创建一个主运行类
02 ///在主运行方法中，创建两个线程，让其交替运行
03 public class threadtest1
04 {
05 public static void main（String[]args）
06 {
07 compute t=new compute（）；
08 compute1 t1=new compute1（）；
09 t.start（）；
10 t1.start（）；
11 }
12 }
13 ///创建compute线程类
14 ///在这个线程类中，通过循环语句输出1～10十个整型数据
15 class compute extends Thread
16 {
17 int i=0；
18 public void run（）
19 {
20 for（int i=0；i＜10；i++）
21 {
22 System.out.println（i）；
23 }
24 }
25 }
26 ///创建compute1线程类
27 ///在这个线程类中，通过循环语句输出说明性语句
28 class compute1 extends Thread
29 {
30 public void run（）
31 {
32 for（int i=0；i＜10；i++）
33 {
34 System.out.println（"这个数字是："+i）；
35 }
36 }
37 }

线程的使用

• 线程的优先级
  线程的执行是一种抢占方式，优先级高的比优先级低的要获得更多的执行时间，如果想让一个线程比其他线程有更多的时间运行，可以通过设置线程的优先级解决。
  设置优先级具体方法：

public final void setPriority（int newPriority）；

newPriority是一个1～10之间的正整数，数值越大，优先级别越高。
系统有一些常数值，如下所示：

public final static int MIN_PRIORITY=1：//表示最低优先级
public final static int MAX_PRIORITY=10：//表示最高优先级
public final static int NORM_PRIORITY=5：//表示默认优先级

实例

01 ///创建一个主运行类
02 ///在主运行方法中，创建两个线程，让其交替运行
03 public class thread2
04 {
05 public static void main（String[]args）
06 {
07 compute t=new compute（）；
08 compute1 t1=new compute1（）；
09 t.setPriority（10）；
10 t1.setPriority（1）；
11 t.start（）；
12 t1.start（）；
13 try
14 {
15 Thread.sleep（5000）；//等待5秒
16 }
17 catch（InterruptedException e）
{}
18 }
19 }
20 ///创建compute线程类
21 ///在这个线程类中，通过循环语句输出1～10十个整型数据
22 class compute extends Thread
23 {
24 int i=0；
25 public void run（）
26 {
27 for（int i=0；i＜10；i++）
28 {
29 System.out.println（i）；
30 }
31 }
32 }
33 ///创建compute1线程类
34 ///在这个线程类中，通过循环语句输出说明语句
35 class compute1 extends Thread
36 {
37 public void run（）
38 {
39 for（int i=0；i＜10；i++）
40 {
41 System.out.println（"这个数字是："+i）；
42 }
43 }
44 }

运行效果

0 1
2 3
4 5
6 7
8 9
这个数字是：0
这个数字是：1
这个数字是：2
这个数字是：3
这个数字是：4
这个数字是：5
这个数字是：6
这个数字是：7
这个数字是：8
这个数字是：9

线程的休眠与唤醒

• 线程的休眠——sleep（）
  线程的休眠，是指线程暂时处于等待的一种状态。sleep（）方法的方法结构如下所示：

public static native void sleep（long millis）throws interruptedExcption

“millis”参数是指线程休眠的毫秒数

线程的唤醒——interrupt（）

线程的唤醒是指，使线程从休眠等待状态进入可执行状态，可以调用方法“interrupt（）”实现。

01 //这是一个主运行类
02 ///创建一个线程对象，通过唤醒功能，使其输出结果发生变化
03 public class thread6
04 {
05 public static void main（String[]args）
06 {
07 compute t=new compute（）；
08 t.start（）；
09 t.interrupt（）；
10 }
11 }
12 ///创建一个线程类，在这个类中，通过休眠，让线程运行输出不同的结果
13 class compute extends Thread
14 {
15 int i=0；
16 public void run（）
17 {
18 System.out.println（"在工作中，不要打扰"）；
19 try
20 {
21 sleep（1000000）；
22 }
23 catch（Exception e）{
System.out.println（"哦，电话来了"）；
}
24 }
25 }

运行效果

在工作中，不要打扰
哦，电话来了

线程让步——yied（）

所谓线程让步，就是使当前正在运行的线程对象退出运行状态，让其他线程运行，其方法是通过调用yield（）来实现。

01 ///这是一个主运行类
02 ///在主运行方法中，通过创建两个线程对象，让其交替执行
03 public class thread7
04 {
05 public static void main（String[]args）
06 {
07 compute t=new compute（）；
08 compute1 t1=new compute1（）；
09 t.start（）；
10 t1.start（）；
11 }
12 }
13 ///创建一个线程类
14 ///通过循环语句来输出十个整型数据
15 ///通过让步程序让此线程停止运行
16 class compute extends Thread
17 {
18 int i=0；
19 public void run（）
20 {
21 for（int i=0；i＜10；i++）
22 {
23 System.out.println（i）；
24 yield（）；
25 }
26 }
27 }
28 ///创建一个线程类
29 ///通过循环语句来输出说明语句
30 class compute1 extends Thread
31 {
32 public void run（）
33 {
34 for（int i=0；i＜10；i++）
35 {
36 System.out.println（"这个数字是："+i）；
37 }
38 }
39 }

运行效果

0 这个数字是：0
这个数字是：1
这个数字是：2
这个数字是：3
这个数字是：4
这个数字是：5
这个数字是：6
这个数字是：7
1 这个数字是：8
这个数字是：9
2 3
4 5
6 7
8 9

线程同步

• 同步块
  同步块是使具有某个对象监视点的线程，获得运行权限的一种方法，每个对象只能在拥有这个监视点的情况下，才能获得运行权限。

synchronized（someobject）
{
//代码段
}

“someobject”是一个监视点对象，可以是实际存在的，也可以是假设的。在很多程序段中，这个监视点对象都是假设的。其实这个监视点就相当于一把锁，给一个线程上了锁，那么其他线程就会被拒之门外，就无法得到这把锁。直到这个线程执行完了，才会将这个锁交给其他线程。其他的线程得到锁后，将自己的程序锁住，再将其他线程拒之门外。

01///这是一个主运行类
02 ///在主运行方法中，通过创建三个线程对象，让其交替执行
03 public class thread10
04 {
05 public static void main（String[]args）
06 {
07 compute t=new compute（'a'）；
08 compute t1=new compute（'b'）；
09 compute t2=new compute（'c'）；
10 t.start（）；
11 t1.start（）；
12 t2.start（）；
13 }
14 }
15 ///创建一个线程类
16 ///在这个线程类中，使用循环语句输出字符
17 ///在run方法中，使用同步块来给线程加一把锁
18 class compute extends Thread
19 {
20 char ch；
21 static Object obj=new Object（）；
22 compute（char ch）
23 {
24 this.ch=ch；
25 }
26 public void print（char ch）
27 {
28 for（int i=1；i＜10；i++）
29 {
30 System.out.print（ch）；
31 }
32 }
33 
34 public void run（）
35 {
36 synchronized（obj）
37 {
38 for（int i=1；i＜10；i++）
39 {
40 print（ch）；
41 System.out.println（）；
42 }
43 }
44 }
45 }

运行效果

aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc

• 同步方法
  同步方法就是对整个方法进行同步。它
  的结构是：

synchronized void f（）
{
//代码
}

01 ///这是一个主运行类
02 ///在主运行方法中，通过创建三个线程对象，让其交替执行
03 public class thread12
04 {
05 public static void main（String[]args）
06 {
07 compute t=new compute（）；
08 new Thread（t）.start（）；
09 new Thread（t）.start（）；
10 new Thread（t）.start（）；
11 }
12 }
13 ///创建一个线程类
14 ///在这个线程类中，使用循环语句输出字符
15 ///在run方法中，使用同步方法来给线程加一把锁
16 class compute extends Thread
17 {
18 int i=10；
19 static Object obj=new Object（）；
20 synchronized void print（）
21 {
22 System.out.println（Thread.currentThread（）.getName（）+"："+i）；
23 i--；
24 }
25 public void run（）
26 {
27 while（i＞0）
28 {
29 print（）；
30 try
31 {
32 sleep（1000）；
33 }
34 catch（Exception e）{}
35 }
36 }
37 }

运行效果

Thread-1：10
Thread-2：9
Thread-3：8
Thread-3：7
Thread-1：6
Thread-2：5
Thread-3：4
Thread-1：3
Thread-2：2
Thread-3：1
Thread-1：0
Thread-2：-1