JAVA教程之java进修日志(线程)

自己的整个学习思路完全被老师的讲课思路所牵制，这样几节课听下来，恐怕自己的见解都应该是书里的知识点了，根本谈不上自身发现问题，分析问题，和解决问题能力的切实提高。1、线程的观点：
线程与历程类似，是一段完成某个特定功效的代码，是程序中单个按次的流把持；但与历程分歧的是，同类的多个线程是共享一块内存空间和一组体系资本，而线程自己的数据一般只要微处置器的存放器数据，和一个供程序实行时利用的仓库。以是体系在发生一个线程，大概在各个线程之间切换时，包袱要比历程小的多，正因云云，线程被称为轻负荷历程（light-weightprocess）。一个历程中能够包括多个线程。

一个线程是一个程序外部的按次把持流。
　　1.历程：每一个历程都有自力的代码和数据空间（历程高低文），历程切换的开支年夜。
　　2.线程：轻量的历程，统一类线程共享代码和数据空间，每一个线程有自力的运转栈和程序计数器（PC），线程切换的开支小。
　　3.多历程：在操纵体系中，能同时运转多个义务程序。
　　4.多线程：在统一使用程序中，有多个按次流同时实行。

Java内涵撑持多线程，它的一切类都是在多线程下界说的，Java使用多线程使全部体系成为异步体系。
　　1.假造的CPU，封装在java.lang.Thread类中。
　　2.CPU所实行的代码，传送给Thread类。
　　3.CPU所处置的数据，传送给Thread类。

2、线程的机关
线程实例暗示Java注释器中的真实的线程，经由过程它能够启动线程、停止线程、线程挂起等，每一个线程都是经由过程类Thread在Java的软件包Java.lang中界说，它的机关办法为：

　　　publicThread（ThreadGroupgroup，Runnabletarget，Stringname）；

　　个中，group指明该线程所属的线程组；target实践实行线程体的方针对象，它必需完成接口Runnable；name为线程名。Java中的每一个线程都有本人的称号，Java供应了分歧Thread类机关器，同意给线程指命名称。假如name为null时，则Java主动供应独一的称号。
当上述机关办法的某个参数为null时，我们可失掉上面的几个机关办法：

　　publicThread（）；
　　publicThread（Runnabletarget）；
　　publicThread（Runnabletarget，Stringname）；
　　publicThread（Stringname）；
　　publicThread（ThreadGroupgroup，Runnabletarget）；
　　publicThread（ThreadGroupgroup，Stringname）；

　　一个类声明完成Runnable接口就能够充任线程体，在接口Runnable中只界说了一个办法run（）：
　　　　　　　publicvoidrun（）；

　　任何完成接口Runnable的对象都能够作为一个线程的方针对象，类Thread自己也完成了接口Runnable，因而我们能够经由过程两种办法完成线程体。

　　（一）界说一个线程类，它承继线程类Thread偏重写个中的办法run（），这时候在初始化这个类的实例时，方针target可为null，暗示由这个实例对来实行线程体。因为Java只撑持单重承继，用这类办法界说的类不克不及再承继别的父类。

　　（二）供应一个完成接口Runnable的类作为一个线程的方针对象，在初始化一个Thread类大概Thread子类的线程对象时，把方针对象传送给这个线程实例，由该方针对象供应线程体run（）。这时候，完成接口Runnable的类仍旧能够承继别的父类。



3、线程的形态
　　每一个线程都是经由过程某个特定Thread对象的办法run()来完成其操纵的，办法run()称为线程体。下图暗示了java线程的分歧形态和形态之间转换所挪用的办法。

1.创立形态(newThread)
　　实行以下语句时，线程就处于创立形态：
　　ThreadmyThread=newThread();
　　当一个线程处于创立形态时，它仅仅是一个空的线程对象，体系不为它分派资本。

　　2.可运转形态(Runnable)
　　ThreadmyThread=newThread();
　　myThread.start();
　　当一个线程处于可运转形态时，体系为这个线程分派了它需的体系资本，布置其运转并挪用线程运转办法，如许就使得该线程处于可运转(Runnable)形态。必要注重的是这一形态并非运转中形态（Running)，由于线程大概实践上并未真正运转。因为良多盘算机都是单处置器的，以是要在统一时候运转一切的处于可运转形态的线程是不成能的，Java的运转体系必需完成调剂来包管这些线程共享处置器。
　　
　　3.不成运转形态（NotRunnable）
　　进进不成运转形态的缘故原由有以下几条：
　　1)挪用了sleep（）办法;
　　2)挪用了suspend（）办法;
　　3)为期待一个前提变量，线程挪用wait（）办法;
　　4)输出输入流中产生线程堵塞;
　　不成运转形态也称为堵塞形态（Blocked）。由于某种缘故原由（输出/输入、守候动静或别的堵塞情形），体系不克不及实行线程的形态。这时候即便处置器余暇，也不克不及实行该线程。

　　4.出生形态（Dead）
　　线程的停止一样平常可经由过程两种办法完成：天然取消（线程实行完）或是被中断（挪用stop()办法）。今朝不保举经由过程挪用stop()来停止线程的实行，而是让线程实行完。


4、有关线程的一些长用的办法
1.sleep(longmillis)
这个办法是一个静态的办法，也就是说我们能够间接挪用它，如Thread.sleep(5000)就是指让今朝正在运转的线程先停下事情守候5000毫秒。有一点必要注重的是：不克不及一定这个线程在过5000毫秒一定会立即被实行。

2.interrupt()
这个办法用来打断一个线程(感到说就寝中的历程加倍符合)。这个办法的感化能够举个例子来看一下:
publicclassTestInterruptextendsThread
{

/**CreatesanewinstanceofTestInterrupt*/
publicTestInterrupt()
{
}

publicvoidrun()
{
try
{

for(inti=0;i<5;i++)
{
System.out.println("runningthefirstloop"+i);
}
Thread.sleep(10000);

for(inti=6;i<10;i++)
{
System.out.println("runningthesecondloop"+i);
}

}catch(InterruptedExceptionie)
{
System.out.println("Sleepinterruptedinrun()");
for(inti=11;i<15;i++)
{
System.out.println("runningthethirdloop"+i);
}

}

}

publicstaticvoidmain(String[]args)
{
TestInterruptti=newTestInterrupt();
Threadt=newThread(ti);
t.start();

//Delayforafewsecondstolettheotherthreadgetgoing
try
{
Thread.sleep(2500);
}catch(InterruptedExceptionie)
{
System.out.println("Sleepinterruptedinmain()");
}

System.out.println("Abouttowakeuptheotherthread");
t.interrupt();
System.out.println("ExitingfromMain");

}
}

下面的例子中假设没有t.interropt()的话，程序运转做的就是
for(inti=6;i<10;i++)
{
System.out.println("runningthesecondloop"+i);
}
加上今后做的就是catch中的内容了.

3.join()和join(longmillis)
join()这个函数的感化是使得今朝正在运转的线程假设为a停上去，一向到挪用join()办法的这个线程b被实行终了，再持续一入手下手的线程a;
看个例子好了:
publicclassTestJoin1extendsThread
{

/**CreatesanewinstanceofTestJoin1*/
publicTestJoin1()
{
}

publicvoidrun()
{
try
{

for(inti=0;i<5;i++)
{
System.out.println("runningthefirstloop"+i);
}
Thread.sleep(1000);

for(inti=6;i<10;i++)
{
System.out.println("runningthesecondloop"+i);
}

}catch(InterruptedExceptionie)
{
System.out.println("Sleepinterruptedinrun()");
}

}

publicstaticvoidmain(String[]args)
{
try
{
TestJoin1ti=newTestJoin1();
Threadt=newThread(ti);
t.start();
t.join();

for(inti=11;i<15;i++)
{
System.out.println("runningthethirdloop"+i);
}
}catch(InterruptedExceptionie)
{
System.out.println("Joininterruptedinrun()");
}

System.out.println("ExitingfromMain");

}
}
这个程序的了局是先让t.join()时候正在运转的线程(实在就是main)被弃捐,做完了t这个线程的一切内容，再回到main线程持续做的t.join();语句后剩下的内容.假设把t.join()这行往失落的话，在一样平常的盘算机上跑出来的了局应当是先做了main一切的内容再往做t线程的内容.

join(longmillis)这个办法和join()办法差未几，都是正在实行的线程a被弃捐，往做挪用join(longmillis)这个办法的线程b的run内里的内容。但前面的millis这个参数决意了b这个线程能被优先运转几工夫(millis代表几毫秒)，millis豪秒事后b线程即便没有运转终了，也会回到线程a.
底下的一个程序能很好的申明这个成绩:
publicclassTestJoin2extendsThread
{

/**CreatesanewinstanceofTestJoin2*/
publicTestJoin2()
{
}

publicvoidrun()
{
try
{

for(inti=0;i<5;i++)
{
System.out.println("runningthefirstloop"+i);
}
Thread.sleep(3500);

for(inti=6;i<10;i++)
{
System.out.println("runningthesecondloop"+i);
}

}catch(InterruptedExceptionie)
{
System.out.println("Sleepinterruptedinrun()");
}

}

publicstaticvoidmain(String[]args)
{
try
{
TestJoin2t2=newTestJoin2();
Threadt=newThread(t2);
t.start();
t.join(3000);

for(inti=11;i<15;i++)
{
System.out.println("runningthethirdloop"+i);
}
}catch(InterruptedExceptionie)
{
System.out.println("Joininterruptedinrun()");
}
System.out.println("ExitingfromMain");

}
}

看了这么多今后，好象很简单发生一种曲解join()这个函数就是让挪用这个办法的线程b优先(第一个)被实行.实在现实并非如许的，join()的感化如下面所说的，它只能让今朝运转的线程a弃捐等，等b实行终了再入手下手实行a.
底下的程序可让人打消这中曲解:
publicclassTestextendsThread
{
publicTest(Stringa)
{
super(a);
}


publicvoidrun()
{
System.out.println(this.getName());
}

publicstaticvoidmain(String[]args)
{
Testa=newTest("a");
Testb=newTest("b");
Testc=newTest("c");

a.start();
b.start();
c.start();
try
{
c.join();
}
catch(Exceptione){
}
System.out.println("ThisisMain!");
}
}

看了运转了局是a,b先被实行了，然后才是c,最初是main^^;

4.关于synchronized
这个关头字呈现的目标是为了让几个线程能同步，举一个最复杂的例子。一个影戏院有20张票要卖，它有3个售票员。
写个程序来证明一下不必synchronized的了局好了，必要利用sleep()函数来打造出这类大概(线程的实行机会谁也不克不及意料)呈现的情形:
publicclassSell
{
publicstaticvoidmain(String[]args)
{
SellThreadsell=newSellThread();
Threadsell1=newThread(sell,"sellman1");
Threadsell2=newThread(sell,"sellman2");
Threadsell3=newThread(sell,"sellman3");
sell1.start();
sell2.start();
sell3.start();
}
}

classSellThreadimplementsRunnable
{
privateinti=20;
publicvoidrun()
{
while(true)
{
if(i>0)
{
try
{
Thread.sleep(100);
}catch(Exceptione)
{
}

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

了局一共卖失落了22张票(估量影戏院觉得事出有因多收了门票钱会很乐意，不外一会大概就要面临恼怒的主顾了....)
这个时分我们的synchronized应当发扬感化了^^修正程序以下:
publicclassSell2
{
publicstaticvoidmain(String[]args)
{
SellThreadsell=newSellThread();
Threadsell1=newThread(sell,"sellman1");
Threadsell2=newThread(sell,"sellman2");
Threadsell3=newThread(sell,"sellman3");
sell1.start();
sell2.start();
sell3.start();
}
}

classSellThreadimplementsRunnable
{
privateinti=20;
Stringa="nowok!";
publicvoidrun()
{
while(true)
{
synchronized(a)
{
if(i>0)
{
try
{
Thread.sleep(100);
}catch(Exceptione)
{
}

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

如许就行了只会卖20张票了，synchronized()中的括号中必要的是一个class的对象以是我们不克不及间接在括号中写上i,就界说了一个String的对象a,a的标记旗(不晓得说甚么更符合)原本为1代表人人都能利用,如许一个售票员selln的卖票线程拿到了a今后他就能够入手下手卖票，同时他把a这个对象标记旗置为0,然后其他售票员卖票的线程发明他们拿不到a这个对象了就只先弃捐了.一向到selln的卖票线程开释了a,a的标记旗就又酿成了1,这个时分其他售票员的卖票的线程就能够合作了，看谁先拿到a这个对象.不外Stringa和卖票没甚么干系，以是我们能够用this来取代synchronized()中的a，它和a的效果一样暗示谁拿到了this对象才干实行.


这里有两个简单曲解的中央:
(1).一个线程拿到synchronized的括号中的对象以后,其他也要必要拿到这个对象才干运转的线程不克不及被实行了.实际上是其他线程也是能够实行的，但他们实行到了必要synchronized中对象的时分，他们发明对象的标记旗为0，以是只能又被弃捐了。(看来侥幸女神只能同光阴顾一团体^^）以是我们用synchronized来使得线程同步的时分是以就义效力为价值的，以是不必要利用的中央就别用好了.

(2),一个线程拿到synchronized的括号中的对象以后,其他任何线程都不克不及实行了，实在假设其他不必要synchronized的对象才干持续实行的线程仍是能够和拿到synchronized的括号中的对象的线程一同运转的。

有的办法后面被加上了synchronized.实在这个时分就是把这个办法的挪用者，也就是this的标记旗置0了，他不克不及和其他必要this才干运转的线程一同实行，但能够和其他不必要这个this对象的线程一同运转。

5.wait()和notify()大概notifyAll()
这个几个函数是为了使得几个同步的线程依照必定的前后按次实行。
都是和synchronized()一同利用,设()中对象为Obj吧。
有一点必要注重的是，我们应当让必要Obj.wait的线程先启动。由于实行按次是必要Obj.wait()的线程a先启动，然后它运转到Obj.wait()的时分，进进弃捐形态,让其他线程先实行。因而带用Obj.notify()的线程b入手下手实行了，一向到b实行到了Obj.notify()今后(Obj.notify()实践上就是关照由于Obj.wait()被弃捐的线程:"轮到你了"),b被弃捐，然后持续做a的Obj.wait()今后的内容.
以是我们假设让带有Obj.notify()的线程b先运转的话，那末b实行终了今后，b实行的Obj.notify()没有找就任安在因Obj.wait()而进进弃捐形态的线程.然后入手下手做带有Obj.wait()的线程a的话.a运转到了Obj.wait()就进进弃捐形态，守候别的一个线程中的Obj.notify()来叫醒它，不外惋惜它永久也等不到了，由于带有Obj.notify()的线程已到弃捐的线程中来找过它一次，很惋惜的是没找到.因而线程a就一向弃捐了...(感到有点像恋爱剧...);
举个例子好了:
publicclassThreadTest
{
publicstaticvoidmain(String[]args)
{
Storagestor=newStorage();
Countera=newCounter(stor);
Printerb=newPrinter(stor);


a.start();
b.start();
}
}

classStorage
{
publicinti=0;
}

classCounterextendsThread
{
privateStoragea;
publicCounter(Storagestor)
{
a=stor;
}

publicvoidrun()
{
System.out.println("Hi");
try
{
sleep(100);
}
catch(Exceptione){}
inti=0;
while(i<5)
{
synchronized(a)
{
System.out.println("Counter");
a.i=(int)(Math.random()*50);
System.out.println(a.i);
a.notify();
}
System.out.println("Counter2");
++i;
}

}
}

classPrinterextendsThread
{
privateStoragea;
publicPrinter(Storagestor)
{
a=stor;
}

publicvoidrun()
{
inti=0;
while(i<5)
{
synchronized(a)
{
System.out.println("Printer");
try{
a.wait();
}
catch(InterruptedExceptione){}
System.out.println(a.i);
}
System.out.println("Printer2");
++i;
}
}
}

运转好了今后把
try
{
sleep(100);
}
catch(Exceptione){}
这几行正文失落再看看运转了局吧。

另有两点说下：
(1).假设几个线程由于Obj.wait()进进弃捐的话，那末只需一个Obj.notifyAll()实行今后，他们都处于能够运转形态，不外究竟谁先运转我们不就晓得。

(2).sleep()和wait()偶然候能够实行不异的功效不外要注重的是thread.sleep(longa)过了a毫秒今后，暗示能够入手下手实行了，不代表thread立即被实行。thread.wait()一但承受到了thread.notify()今后是立即被实行的.


6...........^^


但是一些大型开发或者是保密型比较高的项目都会用java，原因有2点，一：java是开源的，不怕别人留后门，偷我工具，.net就不一样了，保持微软的一向风格，源代码不公开

是一种为 Internet发展的计算机语言

《JAVA语言程序设计》或《JAVA从入门到精通》这两本书开始学，等你编程有感觉的时候也可以回看一下。《JAVA读书笔记》这本书，因为讲的代码很多，也很容易看懂，涉及到面也到位。是你学习技术巩固的好书，学完后就看看《JAVA编程思想》这本书，找找一个自己写的代码跟书上的代码有什么不一样。

所以现在应用最广泛又最好学的就是J2EE了。 J2EE又包括许多组件，如Jsp,Servlet,JavaBean,EJB,JDBC,JavaMail等。要学习起来可不是一两天的事。那么又该如何学习J2EE呢？当然Java语法得先看一看的，I/O包，Util包，Lang包你都熟悉了吗？然后再从JSP学起。

我大二，Java也只学了一年，觉得还是看thinking in java好，有能力的话看英文原版(中文版翻的不怎么好)，还能提高英文文档阅读能力。

仓酷云

象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。

在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。

你可以去承接一些项目做了，一开始可能有些困难，可是你有技术积累，又考虑周全，接下项目来可以迅速作完，相信大家以后都会来找你的，所以Money就哗啦啦的。。。。。。

Java 编程语言的风格十分接近C、C++语言。

是一种突破用户端机器环境和CPU

任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言

你就该学一学Servlet了。Servlet就是服务器端小程序，他负责生成发送给客户端的HTML文件。JSP在执行时，也是先转换成Servlet再运行的。虽说JSP理论上可以完全取代Servlet，这也是SUN推出JSP的本意，可是Servlet用来控制流程跳转还是挺方便的，也令程序更清晰。接下来你应该学习一下Javabean了，可能你早就看不管JSP在HTML中嵌Java代码的混乱方式了，这种方式跟ASP又有什么区别呢？

其实说这种话的人就如当年小日本号称“三个月拿下中国”一样大言不惭。不是Tomjava泼你冷水，你现在只是学到了Java的骨架，却还没有学到Java的精髓。接下来你得研究设计模式了。

如果你学过HTML，那么事情要好办的多，如果没有，那你快去补一补HTML基础吧。其实JSP中的Java语法也不多，它更象一个脚本语言，有点象ASP。

还好，SUN提供了Javabean可以把你的JSP中的 Java代码封装起来，便于调用也便于重用。

Java 编程语言的风格十分接近C、C++语言。

应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展

是一种为 Internet发展的计算机语言

Java 不同于一般的编译执行计算机语言和解释执行计算机语言。它首先将源代码编译成二进制字节码（bytecode），然后依赖各种不同平台上的虚拟机来解释执行字节码。从而实现了“一次编译、到处执行”的跨平台特性。

至于JDBC，就不用我多说了，你如果用java编过存取数据库的程序，就应该很熟悉。还有，如果你要用Java编发送电子邮件的程序，你就得看看Javamail 了。