进程
进程就是一个运行的程序,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