java线程基础.docx
《java线程基础.docx》由会员分享，可在线阅读，更多相关《java线程基础.docx（32页珍藏版）》请在冰点文库上搜索。
java线程基础
java线程基础
java多线程
文章分类:
Java编程
1.创建线程的两种方式
2.线程的生命周期
3.同步的方式
4.死锁
5.生产消费模型、监控模型创建线程的两种方式Java代码
publicclassThread1extendsThread{
privateintj;
//重写run方法
publicvoidrun（）{
for（;j<100;j++）{
System.out.println（getName（）+""+j）;
}
}
//主函数
publicstaticvoidmain（Stringargs[]）{
for（inti=0;i<100;i++）{
//打印主线程执行信息
System.out.println（Thread.currentThread（）.getName（）+""+i）;
if（i==20）{
//新启两个线程
newThread1（）.start（）;
newThread1（）.start（）;
}
}
}
}
publicclassThread2implementsRunnable{
privateintj;
//实现run方法
publicvoidrun（）{
for（;j<100;j++）{
System.out.println（Thread.currentThread（）.getName（）+""+j）;
}
}
//主方法
publicstaticvoidmain（Stringargs[]）{
for（inti=0;i<100;i++）{
//打印主线程执行信息
System.out.println（Thread.currentThread（）.getName（）+""+i）;
if（i==20）{
//新启两个线程
Thread2thread=newThread2（）;
newThread（thread,"新线程1"）.start（）;
newThread（thread,"新线程2"）.start（）;
}
}
}
}
publicclassThread1extendsThread{
privateintj;
//重写run方法
publicvoidrun（）{
for（;j<100;j++）{
System.out.println（getName（）+""+j）;
}
}
//主函数
publicstaticvoidmain（Stringargs[]）{
for（inti=0;i<100;i++）{
//打印主线程执行信息
System.out.println（Thread.currentThread（）.getName（）+""+i）;
if（i==20）{
//新启两个线程
newThread1（）.start（）;
newThread1（）.start（）;
}
}
}
}
publicclassThread2implementsRunnable{
privateintj;
//实现run方法
publicvoidrun（）{
for（;j<100;j++）{
System.out.println（Thread.currentThread（）.getName（）+""+j）;
}
}
//主方法
publicstaticvoidmain（Stringargs[]）{
for（inti=0;i<100;i++）{
//打印主线程执行信息
System.out.println（Thread.currentThread（）.getName（）+""+i）;
if（i==20）{
//新启两个线程
Thread2thread=newThread2（）;
newThread（thread,"新线程1"）.start（）;
newThread（thread,"新线程2"）.start（）;
}
}
}
}结果：
从图片上我们可以看到，第一张图片数据之间没有实现共享，但是第二张图片，我们可以看到线程1和线程2共享了线程类的实例属性，这是因为程序所创建的Runnable对象只是线程的的target,而多个线程可以共享一个target;
对于用继承Thread和实现Runnable,采用Runnable的话该实现类还可以进行继承，扩展性更强；
启动一个线程用的是start（）,而不是run（）;如果直接用run（）则会将它当作一个普通的方法来使用；用start（）,则会将run方法当作线程执行体来处理；
前面的两个示例，实际上至少有三条线程，主线程和程序显示创建的两条线程；主线程的线程执行体不是由run方法来确定的，而是由main方法来确定的线程的生命周期
当程序用new关键字创建一个线程之后，该线程就处于新建状态，此时它和其它Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化了其成员变量的值。
当线程调用了start方法后，该线程处于就绪状态；
同步的方式
一.synchronized关键字保证同步
锁定方法：
表示这个方法同时只能被一个线程访问Java代码
//同步方法同步监视器为this
publicsynchronizedintgetM1（intcount）{
return1;
}
//同步方法同步监视器为this
publicsynchronizedintgetM1（intcount）{
return1;
}锁定对象：
表示其限定的代码块只能同时被一个线程访问Java代码
//同步代码块
publicvoidgetM2（）{
synchronized（obj）{
//代码块，obj为同步监视器
}
}
//同步代码块
publicvoidgetM2（）{
synchronized（obj）{
//代码块，obj为同步监视器
}
}二.新用JDK1.5新的同步机制Java代码
privateLocklock=newReentrantLock（）;
//在方法内使用同步锁
publicvoidgetM3（）{
//开始锁
lock.lock（）;
//同步区。
。
。
try{
}finally{
//释放锁
lock.unlock（）;
}
}
privateLocklock=newReentrantLock（）;
//在方法内使用同步锁
publicvoidgetM3（）{
//开始锁
lock.lock（）;
//同步区。
。
。
try{
}finally{
//释放锁
lock.unlock（）;
}
}
死锁
当两线程相互等待对方释放同步监视器时就会出现死锁，一旦出现死锁，整个程序既不会发生任何的异常，也不会给出任何的提示，只是所有线程处理阻塞状态，无法继续Java代码
classA{
synchronizedvoidfoo（Bb）{
Stringname=Thread.currentThread（）.getName（）;
System.out.println（name+"enteredA.foo"）;
try{
Thread.sleep（1000）;
}catch（Exceptione）{
System.out.println（"AInterrupted"）;
}
System.out.println（name+"tryingtocallB.last（）"）;
//因为b对象被锁住了，调用b内的方法时，在等锁的释放
b.last（）;
}
synchronizedvoidlast（）{
System.out.println（"InsideA.last"）;
}
}
classB{
synchronizedvoidbar（Aa）{
Stringname=Thread.currentThread（）.getName（）;
System.out.println（name+"enteredB.bar"）;
try{
Thread.sleep（1000）;
}catch（Exceptione）{
System.out.println（"BInterrupted"）;
}
System.out.println（name+"tryingtocallA.last（）"）;
//因为a对象被锁住了，调用a内的方法时，在等锁的释放
a.last（）;
}
synchronizedvoidlast（）{
System.out.println（"InsideA.last"）;
}
}
classDeadlockimplementsRunnable{
Aa=newA（）;
Bb=newB（）;
Deadlock（）{
Thread.currentThread（）.setName（"MainThread"）;
Threadt=newThread（this,"RacingThread"）;
t.start（）;
a.foo（b）;//同步监视器为a
System.out.println（"Backinmainthread"）;
}
publicvoidrun（）{
b.bar（a）;//同步监视器为b
System.out.println（"Backinotherthread"）;
}
publicstaticvoidmain（Stringargs[]）{
newDeadlock（）;
}
}
classA{
synchronizedvoidfoo（Bb）{
Stringname=Thread.currentThread（）.getName（）;
System.out.println（name+"enteredA.foo"）;
try{
Thread.sleep（1000）;
}catch（Exceptione）{
System.out.println（"AInterrupted"）;
}
System.out.println（name+"tryingtocallB.last（）"）;
//因为b对象被锁住了，调用b内的方法时，在等锁的释放
b.last（）;
}
synchronizedvoidlast（）{
System.out.println（"InsideA.last"）;
}
}
classB{
synchronizedvoidbar（Aa）{
Stringname=Thread.currentThread（）.getName（）;
System.out.println（name+"enteredB.bar"）;
try{
Thread.sleep（1000）;
}catch（Exceptione）{
System.out.println（"BInterrupted"）;
}
System.out.println（name+"tryingtocallA.last（）"）;
//因为a对象被锁住了，调用a内的方法时，在等锁的释放
a.last（）;
}
synchronizedvoidlast（）{
System.out.println（"InsideA.last"）;
}
}
classDeadlockimplementsRunnable{
Aa=newA（）;
Bb=newB（）;
Deadlock（）{
Thread.currentThread（）.setName（"MainThread"）;
Threadt=newThread（this,"RacingThread"）;
t.start（）;
a.foo（b）;//同步监视器为a
System.out.println（"Backinmainthread"）;
}
publicvoidrun（）{
b.bar（a）;//同步监视器为b
System.out.println（"Backinotherthread"）;
}
publicstaticvoidmain（Stringargs[]）{
newDeadlock（）;
}
}
生产消费模型、监控模型Java代码
//生产消费模型
publicclassMain{
publicstaticvoidmain（Stringargs[]）{
List<Egg>list=newArrayList<Egg>（）;
newProduct（list）.start（）;
newCustomer（list）.start（）;
}
}publicclassEgg{
privateintid;
privateStringname;
publicintgetId（）{
returnid;
}
publicvoidsetId（intid）{
this.id=id;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringtoString（）{
returnid+""+name;
}
}publicclassProductextendsThread{
privateList<Egg>list;
privateintcount;
publicProduct（List<Egg>list）{
this.list=list;
}
//重写run方法
publicvoidrun（）{
System.out.println（"生产线程启动"）;
while（true）{
try{
Thread.sleep（100）;
synchronized（list）{
//还有鸡蛋时
while（list.size（）>0）{
list.wait（）;
}
//没有鸡蛋时
while（list.size（）==0）{
Eggegg=newEgg（）;
egg.setId（count++）;
egg.setName（"鸡蛋"）;
System.out.println（"生产线程生产"+egg.toString（））;
list.add（egg）;
//通知消费线程
list.notify（）;
}
}
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
}publicclassCustomerextendsThread{
privateList<Egg>list;
publicCustomer（List<Egg>list）{
this.list=list;
}
//重写run方法
publicvoidrun（）{
System.out.println（"消费线程启动"）;
while（true）{
try{
Thread.sleep（100）;
synchronized（list）{
//没有则等待
while（list.size（）==0）{
list.wait（）;
}
//有鸡蛋时
while（list.size（）>0）{
System.out.println（"消费线程消费"+list.remove（0）.toString（））;
//通知生产线程
list.notify（）;
}
}
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
}
//生产消费模型
publicclassMain{
publicstaticvoidmain（Stringargs[]）{
List<Egg>list=newArrayList<Egg>（）;
newProduct（list）.start（）;
newCustomer（list）.start（）;
}
}publicclassEgg{
privateintid;
privateStringname;
publicintgetId（）{
returnid;
}
publicvoidsetId（intid）{
this.id=id;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringtoString（）{
returnid+""+name;
}
}publicclassProductextendsThread{
privateList<Egg>list;
privateintcount;
publicProduct（List<Egg>list）{
this.list=list;
}
//重写run方法
publicvoidrun（）{
System.out.println（"生产线程启动"）;
while（true）{
try{
Thread.sleep（100）;
synchronized（list）{
//还有鸡蛋时
while（list.size（）>0）{
list.wait（）;
}
//没有鸡蛋时
while（list.size（）==0）{
Eggegg=newEgg（）;
egg.setId（count++）;
egg.setName（"鸡蛋"）;
System.out.println（"生产线程生产"+egg.toString（））;
list.add（egg）;
//通知消费线程
list.notify（）;
}
}
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
}publicclassCustomerextendsThread{
privateList<Egg>list;
publicCustomer（List<Egg>list）{
this.list=list;
}
//重写run方法
publicvoidrun（）{
System.out.println（"消费线程启动"）;
while（true）{
try{
Thread.sleep（100）;
synchronized（list）{
//没有则等待
while（list.size（）==0）{
list.wait（）;
}
//有鸡蛋时
while（list.size（）>0）{
System.out.println（"消费线程消费"+list.remove（0）.toString（））;
//通知生产线程
list.notify（）;
}
}
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}
}Java代码
//监控模型publicclassControlimplementsRunnable{
//存放统计线程的队列
privatestaticList<CountFile>list=newArrayList<CountFile>（）;
//主函数
publicstaticvoidmain（Stringargs[]）{
//取得系统的根目录个数
java.io.File[]dirF=java.io.File.listRoots（）;
//根据目录创建统计纯种个数
for（inti=0;i<dirF.length;i++）{
CountFilecf=newCountFile（dirF[i].getAbsolutePath（））;
cf.start（）;
list.add（cf）;
}
System.out.println（dirF.length+"个统计线程已启动"）;
//启动监视线程
ne
升级会员 