线程的基本概念
进程以及使用环境
程序是计算机指令的集合，它以文件形式存储在磁盘上，而进程就是一个执行中的程序，每一个进程都有其独立的内存空间和系统资源。
进程就是一个运行的程序，Windows操作系统是支持多进程的操作系统，即同一时间l可以执行多个程序，每个程序是在自己独立的内存空间内，使用自己被分配到的系统资源。其实，这种说法并不准确，一个CPU在某个时刻，实际上只能运行一个程序，即一个进程。所谓的支持多进程，其实就是CPU在非常快速的交替轮流执行多个程序，例如，利用Windows操作系统可以边听歌曲、一边上网等。
线程以及使用环境
线程是CPU调度和分派的基本单位，一个进程可以由多个线程组成，而这多个线程共享同一个存储空间，这使得线程间的通信比较容易。在一个多进程的程序中，如果要切换到另一个进程，需要改变地址空间的位置。然而在多线程的程)犷中，就不会出现这种情况因为它们位于同一个内存空间内.只需改变运行的顺序即可。
多线程指单个程序可通过同时运行多个不同线程，以执行不同任务。所谓同时，也要依据CPU。如果是多个CPU,则并发运行，如果是一个CPU,则根据系统具体情况，执行多个线程。
线程创建
创建线程的方法一般有两种:
1.通过实现Runnable接口的方式创建线程。
2.通过继承Thread类来创建线程。
通过Runnable接口的方式创建线程
在Java中，线程是一种对象，但不是所有的对象都可以称为线程。只有实现Runnable接口的类，才可以称为线程。先看看Runnable接口的定义:
public interface Runnable
{
public abstract void run();
}
Runnable接口只有一个抽象方法run()。要实现这个接口。只要实现这个抽象方法就可以。只要实现了这个接口的类，才有资格称为线程。
创建线程的结构如下:
Thread t=new Thread(runnable 对象);
runnable对象是指实现了Runnable接口类的对象。当线程执行时.runnable对象中的"run()”方法会被调用，如果想要运行上面创建的线程，还需要调用一个Thread类的方法。
t.start();
例子:
public class threadtest{ //创建测试两个线程类，让其交替运衍
public static void main(String[]args) {
//创建对象c和c1
compute c=new compute();
compute1 c1=new compute1();
//创建线程对象t和t1
Thread t=new Thread(c);
Thread t1=new Thread(c1);
t.start();//启动线程对象t
t1.start();//启动线程对象t1
}
}
//创建通过循环语句输出数字的类
class compute implemeats Runnable{ //创建实现线程的类compute
public void run(){ //实现方法run()
for(int i=0; i<10;i++){
System.out .println(i);
}
}
}
//创建通过循环语句输出数字的类
class compute1 implements Runnable{ //创建实现线程的类compute1
public void run(){//实现方法run()
for(int i=0;i<10;i++){
System.out.println(”这个数字是:”+i);
}
}
}
运行结果：
0
这个数字是:0
1
这个数字是:1
2
这个数字是:2
3
这个数字是:3
4
这个数字是:4
5
这个数字是:5
6
这个数字是:6
7
这个数字是:7
8
这个数字是:8
9
这个数字是:9
PS：这个程序段中，创建了两个线程，不过多次运行后结果可能会有不同。那为什么会输出不同的结果呢?
因为在程序具体运行时会存在执行顺序的问题。在Java技术中，线程通常是通过调度模式来执行的。所谓抢占式调度模式是指，许多线程处于可以运行状态，即等待状态，但实际只有一个线程在运行。该线程一直运行到它终止，或者另一个具有更高优先级变成可运行状态。在后一种情况下，低优先级线程被高优先级线程抢占且获得运行机会。
通过继承Thread类来创建线程
其实Thread类本身也实现了Runnable接口，所以只要让一个类能够继承Thread类，并覆盖"run()”方法，也会创建线程。
例子:
public class threadtest{ //创建测试两个线程类，让其交替运衍
public static void main(String[]args) {
//创建对象c和c1
compute c=new compute();
compute1 c1=new compute1();
//创建线程对象t和t1
Thread t=new Thread(c);
Thread t1=new Thread(c1);
t.start();//启动线程对象t
t1.start();//启动线程对象t1
}
}
//创建通过循环语句输出数字的类
class compute extends Thread{ //创建实现线程的类compute
public void run(){ //实现方法run()
for(int i=0; i<10;i++){
System.out .println(i);
}
}
}
//创建通过循环语句输出数字的类
class compute1 extends Thread{ //创建实现线程的类compute1
public void run(){//实现方法run()
for(int i=0;i<10;i++){
System.out.println(”这个数字是:”+i);
}
}
}
这两种方式的详细使用:
线程的使用
线程的优先级
线程的执行顺序是一种抢占方式，优先级高的比优先级低的要获得更多的执行时间，如果想让一个线程比其他线程有更多的时间运行，可以通过设置线程的优先级解决。
如一个线程创建后，可通过在线程中调用“set Priority()”方法，来设置其优先级，具体方法如下:
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，表示默认优先级。
例子:
public class threadtest{ //创建测试两个线程类，让其交替运衍
public static void main(String[]args) {
//创建对象c和c1
compute c=new compute();
compute1 c1=new compute1();
//创建线程对象t和t1
Thread t=new Thread(c);
Thread t1=new Thread(c1);
t .setPrioritp(10);
t1.setPrioritp(1);
t.start();//启动线程对象t
t1.start();//启动线程对象t1
}
}
//创建通过循环语句输出数字的类
class compute extends Thread{ //创建实现线程的类compute
public void run(){ //实现方法run()
for(int i=0; i<10;i++){
System.out .println(i);
}
}
}
//创建通过循环语句输出数字的类
class compute1 extends Thread{ //创建实现线程的类compute1
public void run(){//实现方法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
此时的输出变得很有规律，因为程序中将输出数字的线程的优先级设为最高了，而输出汉字的线程是系统最低优先级，所以程序执行时，会给数字输出线程更多的时间执行。
线程的休眠和唤醒
线程的休眠
线程的休眠，是指线程暂时处于等待的一种状态，通俗地说，就是线程暂I付停止运行了。
要达到这种功能需要调用Thread类的“sleep()"方法。"sleep()”方法可以使线程在指定的时间，处于暂时停止的状态，等到指定时间结束后，暂时停止状态就会结束，然后继续执行没有完成的任务。"sleep()”方法的方法结构如下
public static native void sleep(long millis)throws interruptedExcption
"millis”参数是指线程休眠的毫秒数。上述代码涉及了抛出异常的问题，由于目前还没有开始讲述抛出异常，所以只要知道是抛出异常就可以。
线程的唤醒
线程的唤醒是指，使线程从休眠等待状态进入可执行状态，可以通过调用方法"interrupt()”来实现。
用法:
public class thread6{
public static void main(String[] args){
compute t=new compute();
t .start()
t .interrupt();
}
}
//创建一个线程类在这个类中通过休眠来输出不同结果
class compute extends Thread{
int i = 0;
public void run(){
//输出相应信息
System.out.println(”在工作中，不要打扰‘’);
try{
sleep(1000000);
}catch(exception e){
System.out.priatla("哦，电话来了’‘);
}
}
}
线程让步
所谓线程让步，就是使当前正在运行的线程对象退出运行状态，让其他线程运行，其方法是通过调用“yield()”方法来实现。这个方法不能将运行权让给指定的线程，只是允许这个线程把运行权让出来，至于给谁，这就需要看由哪个线程抢占到了。
例子:
//创建一个主运行类
public class thread7{
public static void main(String[]args){
//创建两个线程对象t和t1
compute t=new compute();
compute1 t1=new compute1();
//启动两个线程
t.start();
t1.start();
}
}
//创建通过循环语句输出数字的类
class compute extends Thread{ //创建继承线程的类compute
int i=0; //创建成员变量
public void run(){ //实现run()方法
for(int i=0;i<10;i++){
System.out.println(i);
Yield(); //让线程暂停
}
}
}
//创建通过循环语句输出数字的类
class compute1 extends Thread{//创建继承线程的类compute1
public void run(){//实现run()方法
for(int i=0;i<10;i++){
System.out.println(”这个数字是:”+i);
}
}
}
结果:
0
这个数字是:0
这个数字是:1
这个数宇是:2
这个数字是:3
这个数字是:4
这个数字是:5
这个数字是:6
这个数字是:7
1
这个数字是:8
这个数字是:9
2
3
4
5
6
7
8
9
从运行结果来看.第1个线程比第0个线程运行的几率要小，因为它总是放弃运行权
线程同步
前面讲述过，线程的运行权通过一种叫抢占的方式获得。一个程序运行到一半时，突然被另一个线程抢占了运行权，此时这个线程数据处理了一半.而另一个线程也在处理这个数据那么会出现重复操作数据的现象，最终整个系统将会混乱。
同步块
同步块是使具有某个对象监视点的线程，获得运行权限的一种方法，每个对象只能在拥有这个监视点的情况下才能获得运行权限。举个例子，一个圆桌有4个人吃饭，但是只有一个勺子，4人中只有一个人能吃饭，并且，这个人必项是拥有勺子的人，而这个勺子就相当于同步块中的监视点。
同步块的结构如下
synchronized(someobject)
{
代码段
}
"someobject”是一个监视点对象可以是实际存在的，也可以是假设的。在很多程序段中，这个监视点对象都是假设的。其实这个监视点;就相当于一把锁，给一个线程上了锁，那么其他线程就会被拒之门外，就无法得到这把锁。直到这个线程执行完了，才会将这个锁交给其他线程。其他的线程得到锁后，将自己的程序锁住,再将其他线程拒之门外。
例子:
//创建一个主运行类
public class threadl0{
public static void main(String[]
//创建两个线程对象t, t1和t2
compute t=new compute(’a’);
compute t1=new computel(‘b‘);
compute t2”new compute(’c’);
//启动三个线程
t.start();
t1.start();
t2.start();
}
}
//创建通过循环语句输出数字的类
class compute extends Thread{
char ch;
static Object obj=new Object();
compute(char ch){
this.ch=ch;
}
public void print(char ch){
for(int i，0;i<10;i++){
System.out.print(ch);
}
}
public void run(){
synchronized (obj){
for(int i=1;i<10;i++){
print(ch);
System.out.println();
}
}}
}
结果:
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
aaaaaaaaa
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbb
bbbbbbbbbccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
ccccccccc
在运行程序中添加一个监视点，那么将锁内的程序段执行完后，就会自动打开锁，再由另外两个线程抢占这个锁。然后反复执行这个同步块中的程序，这样一个线程执行完后，才会执行另一个线程。对于多线程操作同一个数据。就不会出现混乱的现象。
同步化方法
同步化方法就是对整个方法进行同步。它的结构如下:
synchronized void f()
{
代码
}
例子：
//创建一个主运行类
public class threadl0{
public static void main(String[]
//创建两个线程对象t, t1和t2
compute t=new compute(’a’);
compute t1=new computel(‘b‘);
compute t2”new compute(’c’);
//启动三个线程
t.start();
t1.start();
t2.start();
}
}
//创建通过循环语句输出数字的类
class compute extends Thread{
char ch;
static Object obj=new Object();
compute(char ch){
this.ch=ch;
}
synchronized void print(char ch){
for(int i，0;i<10;i++){
System.out.print(ch);
}
}
public void run(){
for(int i=1;i<10;i++){
print(ch);
System.out.println();
}
}
}
从上面的结果可以看出，使用同步块和同步方法的输出结果是一样的。
实例分析
生产者与消费者
1个汉堡包店，有1个厨师和1个营业员。厕师负责做汉堡包，营业员负责卖汉堡包，当然还有1个存放汉堡包的箱子。厨师不停地做汉堡包，做好了就放在箱子里面，当每次客人来的时候，营业员就会从箱子里面取出1个汉堡包卖掉。假设前提是客人每隔1秒来1个，也就是说营业员1秒卖1个汉堡包，而厨师3秒做1个汉堡包。
目前总共只能做10个汉堡(材料只有10份)，箱子中已经有了5个汉堡，请编写一个程序代码来显示这个买卖的关系。
代码如下:
设计汉堡包盒子类，将其作为监视点，代码如下:
class ham { //创建把装汉堡包的盒子作为监视器类
Static Object box = new Object(); //创建对象box
static int totalmaterial=10; //关于制作汉堡包的材料属性
static int sales=0; //关于销售多少个汉堡包属性
static int production=5; //关于一共有多少个汉堡包属性
}
设计厨师类，代码如下:
class hmaker extends Thread//厨师线程类
{
//make方法使用了一个同步块，在这个函数里会不断地生产汉堡包
public void make(){
synchroaiaed (ham.box){//创建同步块
(ham.production)++;
try{
ham.box.notify();
}catch(Exception e){
}
}
}
public void run(){ //重写run()方法
//使用循环语句来保证在汉堡包材料用完之前，不断地生产汉堡包
while(ham.production<ham.totalmaterial){
//使用判断语句判断只要有汉堡包，厨师就通知营业员可以卖了
if (ham.production>0){
System.out.println("厨师‘.+getName()+”:‘’十”汉堡包来了（总共‘’
+(ham.production-ham.sales)+‘’个)‘’);
}
try{
sleep(3000); //因为3秒后才能制造好一个,线程休眠3秒
}catch(Exception e){
}
make(); //调用make()方法
｝
｝
｝
设计营业员类:
class hassistant extends Thread{ //关于营业员的线程类
public void sell(){ //创建营业员卖汉堡包的方法
if(ham.production==0) //当没有汉堡包时
System.out.println(顾客朋友们，请稍微等一下，汉堡包没了!!);
}
try{
ham.box.wait(); //使线程暂停,等待厨师类的通知
}catch(Exception e){
}
ham.sales++;
System.out.println("营业员:顾客好汉堡包上来了 (总共卖了‘’十ham.sales十’·个));
}
public void run(){ //重写run()方法
//当盒子里面有汉堡包的情况下不断地卖
while(ham.sales<ham.production){
try{
sleep(1000); //线程休眠1秒
}catch(Exception e){
}
sell(); //调用sell()方法
}
}
｝
测试类:
public class thread13{ //创建测试类
public static void main(String[]args){ //主方法
hmaker maker=new hmaker(); //创建对象maker
hassistant assistant=new hassistant(); //创建对象assistant
//对对象maker进行设置
maker .setName(”甲”);
//启动线程
maker.start();
assistant.start();
}
}
厨师类能做汉堡包的产品数量，应该小于总材料的数量。在这个前提条件下，如果产品不等于零，就让厨师告诉一声:汉堡包上来了，曾、共有多少个。接下来开始3秒做1个汉堡包，做好了后，再通知一声:汉堡包上来了，总共几个。另外，只要箱子里的汉堡包不等于零，就通知营业员可以卖了。而营业员类，主要是销售汉堡包，每1秒卖1个，如果箱子里面的汉堡包等于零，就通知顾客:汉堡包没了，需要等待。
结果:
厨师甲:汉堡包来了(总共5个)
营业员:顾客好，汉堡包上来了 (总共卖了1个)
营业员:顾客好，汉堡包上来了 (总共卖了2个)
厨师甲:汉堡包来了(总共4个)
营业员:顾客好，汉堡包上来了 (总共卖了3个)
营业员:顾客好，汉堡包上来了 (总共卖了4个)
营业员:顾客好，汉堡包上来了 (总共卖了5个)
厨师甲:汉堡包来了(总共2个)
营业员:顾客好，汉堡包上来了 (总共卖了6个)
营业员:顾客好汉堡包上来了 (总共卖了7个)
厨师甲:汉堡包来了(总共1个)
厨师甲:汉堡包来了(总共2个)