Java学习笔记(Java名词解释和多线程编程)

名词解释 & JAVA多线程编程名词解释：JNI（Java Native Interface）指的是Java本地调用接口，通过这一接口，Java程序可以和采用其他语言编写的本地程序进行通信。

IPC是两个进程之间进行通信的一种机制。

JMX（Java Management Extensions）是SUN提出的Java管理扩展规范，是一个为应用程序、设备和系统植入管理功能的框架。

JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议。

通过JMX，用户可以灵活地开发无缝集成的系统、网络和服务管理应用。

JNDI（Java Naming and Directory Interface）是一种将对象和名字绑定的技术，对象工厂负责生产出对象，这些对象都和惟一的名字绑定。

外部程序可以通过名字来获得某个对象的引用。

DTD即文档类型定义。

SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议，是Internet 传送E-mail的基本协议，也是TCP/IP协议组的成员。

SMTP解决了E-mail系统如何通过一条链路，把邮件从一台机器传递到另一台机器上的问题。

通常把发送邮件服务器称为SMTP服务器。

POP3（Post Office Protocol3）即邮局协议第3版，这是Internet接收E-mail 的基本协议，也是TCP/IP协议组的成员。

IMAP（Internet Message Access Protocol）即直接收取邮件的协议，是与POP3不同的一种E-mail接收的新协议。

MIME（Multipurpose Internet Mail Extensions）是一种电子邮件编码方式，它可以将发信人的电子邮件中的文本以及各种附件都打包后发送。

SOAP（Simple Object Access Protocol）即简单对象访问协议，是在分散或分布式的环境中交换信息的简单协议，它以XML作为数据传送方式。

OOP即面向对象程序设计OOA（Object Oriented Analysis）即面向对象的分析。

OOD（Object Oriented Design）即面向对象的设计。

OOI（Object Oriented Implementation）即面向对象的实现。

GUI（Graphics User Interface）图形用户界面或图形用户接口。

IFC（Internet Foundation Classer）Internet基本类。

JFC（Java Foundation Classer）Java基本类。

AWT（Abstract Window Toolkit）抽象窗口工具箱JAVA多线程编程synchronized关键字 (记下来，很重要)。

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。

另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。

也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。

结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.举例说明：一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。

另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

package ths;public class Thread1 implements Runnable {public void run() {synchronized(this) {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getNam e() + " synchronized loop " + i);}}}public static void main(String[] args) {Thread1 t1 = new Thread1();Thread ta = new Thread(t1, "A");Thread tb = new Thread(t1, "B");ta.start();tb.start();}}结果：A synchronized loop 0A synchronized loop 1A synchronized loop 2A synchronized loop 3A synchronized loop 4B synchronized loop 0B synchronized loop 1B synchronized loop 2B synchronized loop 3B synchronized loop 4二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

package ths;public class Thread2 {public void m4t1() {synchronized(this) {int i = 5;while( i-- > 0) {System.out.println(Thread.currentThread().getNam e() + " : " + i);try {Thread.sleep(500);} catch (InterruptedException ie) {}}}}public void m4t2() {int i = 5;while( i-- > 0) {System.out.println(Thread.currentThread().getName() + " : " + i);try {Thread.sleep(500);} catch (InterruptedException ie) {}}}public static void main(String[] args) {final Thread2 myt2 = new Thread2();Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, "t1" );Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, "t2" );t1.start();t2.start();}}结果：t1 : 4t2 : 4t1 : 3t2 : 3t1 : 2t2 : 2t1 : 1t2 : 1t1 : 0t2 : 0三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

//修改Thread2.m4t2()方法：public void m4t2() {synchronized(this) {int i = 5;while( i-- > 0) {System.out.println(Thread.currentThread().getNam e() + " : " + i);try {Thread.sleep(500);} catch (InterruptedException ie) {}}}}结果：t1 : 4t1 : 3t1 : 2t1 : 1t1 : 0t2 : 4t2 : 3t2 : 2t2 : 1t2 : 0四、第三个例子同样适用其它同步代码块。

也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。

结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

//修改Thread2.m4t2()方法如下：public synchronized void m4t2() {int i = 5;while( i-- > 0) {System.out.println(Thread.currentThread().getName() + " : " + i);try {Thread.sleep(500);} catch (InterruptedException ie) {}}}结果：t1 : 4t1 : 3t1 : 2t1 : 1t1 : 0t2 : 4t2 : 3t2 : 2t2 : 1t2 : 0五、以上规则对其它对象锁同样适用:package ths;public class Thread3 {class Inner {private void m4t1() {int i = 5;while(i-- > 0) {System.out.println(Thread.currentThread().getNam e() + " : Inner.m4t1()=" + i);try {Thread.sleep(500);} catch(InterruptedException ie) {}}}private void m4t2() {int i = 5;while(i-- > 0) {System.out.println(Thread.currentThread().getNam e() + " : Inner.m4t2()=" + i);try {Thread.sleep(500);} catch(InterruptedException ie) {}}}}private void m4t1(Inner inner) {synchronized(inner) { //使用对象锁inner.m4t1();}private void m4t2(Inner inner) {inner.m4t2();public static void main(String[] args) {final Thread3 myt3 = new Thread3();final Inner inner = myt3.new Inner();Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");Thread t2 = new Thread( new Runnable() {public void run(){ myt3.m4t2(inner);} }, "t2");t1.start();t2.start();}}结果：尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner 中的非同步部分。