public int getX() {
        return x;
    }

    public int fix(int y) {
        x = x - y;
        return x;
    }
}
 
public class MyRunnable implements Runnable {
    private Foo foo = new Foo();

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread ta = new Thread(r, "Thread-A");
        Thread tb = new Thread(r, "Thread-B");
        ta.start();
        tb.start();
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            this.fix(30);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX());
        }
    }

    public int fix(int y) {
        return foo.fix(y);
    }
}
 
运行结果：
Thread-A : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= 40
Thread-B : 当前foo对象的x值= -20
Thread-A : 当前foo对象的x值= -50
Thread-A : 当前foo对象的x值= -80
Thread-B : 当前foo对象的x值= -80

Process finished with exit code 0
 
从结果发现，这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。
 
如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。
 
在具体的Java代码中需要完成一下两个操作：
把竞争访问的资源类Foo变量x标识为private；
同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。
 
二、同步和锁定
 
1、锁的原理
 
Java中每个对象都有一个内置锁
 
当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。
 
当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。
 
一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。
 
释放锁是指持锁线程退出了synchronized同步方法或代码块。
 
关于锁和同步，有一下几个要点：
1）、只能同步方法，而不能同步变量和类；
2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？
3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。
4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。
5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。
6）、线程睡眠时，它所持的任何锁都不会释放。

7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。
8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。
9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如：
    public int fix(int y) {
        synchronized (this) {
            x = x - y;
        }
        return x;
    }
 
当然，同步方法也可以改写为非同步方法，但功能完全一样的，例如：
    public synchronized int getX() {
        return x++;
    }
与
    public int getX() {
        synchronized (this) {
            return x;
        }
    }
效果是完全一样的。
 
三、静态方法同步
 
要同步静态方法，需要一个用于整个类对象的锁，这个对象是就是这个类（XXX.class)。
例如：
public static synchronized int setName(String name){
      Xxx.name = name;
}
等价于
public static int setName(String name){
      synchronized(Xxx.class){
            Xxx.name = name;
      }
}

 
四、如果线程不能不能获得锁会怎么样
 
如果线程试图进入同步方法，而其锁已经被占用，则线程在该对象上被阻塞。实质上，线程进入该对象的的一种池中，必须在哪里等待，直到其锁被释放，该线程再次变为可运行或运行为止。
 
当考虑阻塞时，一定要注意哪个对象正被用于锁定：
1、调用同一个对象中非静态同步方法的线程将彼此阻塞。如果是不同对象，则每个线程有自己的对象的锁，线程间彼此互不干预。
 
2、调用同一个类中的静态同步方法的线程将彼此阻塞，它们都是锁定在相同的Class对象上。
 
3、静态同步方法和非静态同步方法将永远不会彼此阻塞，因为静态方法锁定在Class对象上，非静态方法锁定在该类的对象上。
 
4、对于同步代码块，要看清楚什么对象已经用于锁定（synchronized后面括号的内容）。在同一个对象上进行同步的线程将彼此阻塞，在不同对象上锁定的线程将永远不会彼此阻塞。
 
五、何时需要同步
 
在多个线程同时访问互斥（可交换）数据时，应该同步以保护数据，确保两个线程不会同时修改更改它。
 
对于非静态字段中可更改的数据，通常使用非静态方法访问。
对于静态字段中可更改的数据，通常使用静态方法访问。
 
如果需要在非静态方法中使用静态字段，或者在静态字段中调用非静态方法，问题将变得非常复杂。已经超出SJCP考试范围了。
 
六、线程安全类
 
当一个类已经很好的同步以保护它的数据时，这个类就称为“线程安全的”。
 
即使是线程安全类，也应该特别小心，因为操作的线程是间仍然不一定安全。
 
举个形象的例子，比如一个集合是线程安全的，有两个线程在操作同一个集合对象，当第一个线程查询集合非空后，删除集合中所有元素的时候。第二个线程也来执行与第一个线程相同的操作，也许在第一个线程查询后，第二个线程也查询出集合非空，但是当第一个执行清除后，第二个再执行删除显然是不对的，因为此时集合已经为空了。
看个代码：
 
public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public void add(String name) {
        nameList.add(name);
    }

    public String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}
 
public class Test {
    public static void main(String[] args) {
        final NameList nl = new NameList();
        nl.add("aaa");
        class NameDropper extends Thread{
            public void run(){
                String name = nl.removeFirst();
                System.out.println(name);
            }
        }

        Thread t1 = new NameDropper();
        Thread t2 = new NameDropper();
        t1.start();
        t2.start();
    }
}
 
虽然集合对象
    private List nameList = Collections.synchronizedList(new LinkedList());
是同步的，但是程序还不是线程安全的。
出现这种事件的原因是，上例中一个线程操作列表过程中无法阻止另外一个线程对列表的其他操作。
 
解决上面问题的办法是，在操作集合对象的NameList上面做一个同步。改写后的代码如下：
public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public synchronized void add(String name) {
        nameList.add(name);
    }

    public synchronized String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}
 
这样，当一个线程访问其中一个同步方法时，其他线程只有等待。
 
七、线程死锁
 
死锁对Java程序来说，是很复杂的，也很难发现问题。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。
 
还是看一个比较直观的死锁例子：
 
public class DeadlockRisk {
    private static class Resource {
        public int value;
    }

    private Resource resourceA = new Resource();
    private Resource resourceB = new Resource();

    public int read() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                return resourceB.value + resourceA.value;
            }
        }
    }

    public void write(int a, int b) {
        synchronized (resourceB) {
            synchronized (resourceA) {
                resourceA.value = a;
                resourceB.value = b;
            }
        }
    }
}
 
假设read()方法由一个线程启动，write()方法由另外一个线程启动。读线程将拥有resourceA锁，写线程将拥有resourceB锁，两者都坚持等待的话就出现死锁。
 
实际上，上面这个例子发生死锁的概率很小。因为在代码内的某个点，CPU必须从读线程切换到写线程，所以，死锁基本上不能发生。
 
但是，无论代码中发生死锁的概率有多小，一旦发生死锁，程序就死掉。有一些设计方法能帮助避免死锁，包括始终按照预定义的顺序获取锁这一策略。已经超出SCJP的考试范围。
 
八、线程同步小结
 
1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。
3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。

   //循环加载jar包
for /f %%i in ('dir /b %LIBPATH%\*.jar^|sort') do (
   set CP=!CP!%LIBPATH%\%%i;
)

echo ===============================================================================
echo.
echo   Engine Startup Environment
echo.
echo   JAVA: %JAVA%
echo.
echo   CONFIG: %CONFIG%
echo.
echo   JAVA_OPTS: %OPTS%
echo.
echo   CLASSPATH: %CP%
echo.
echo ===============================================================================
echo.

%JAVA% %OPTS% -cp %CP% %MAIN% //运行

# 以下为服务器、数据库信息

dbPort = localhost

databaseName = mydb

dbUserName = root

dbPassword = root

# 以下为数据库表信息

dbTable = mytable

# 以下为服务器信息

ip = 192.168.0.9

在上面的文件中我们假设该文件名为： test.properties 文件。其中 # 开始的一行为注释信息；在等号“ = ”左边的我们称之为 key ；等号“ = ”右边的我们称之为 value 。（其实就是我们常说的键 - 值对） key 应该是我们程序中的变量。而 value 是我们根据实际情况配置的。 

二． JDK 中的 Properties 类 Properties 类存在于胞 Java.util 中，该类继承自 Hashtable ，它提供了几个主要的方法：

1． getProperty ( String key) ，   用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value。

2． load ( InputStream inStream) ，从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。

3． setProperty ( String key, String value) ，调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置 键 - 值对。 

4． store ( OutputStream out, String comments) ，   以适合使用 load 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。

5． clear () ，清除所有装载的 键 - 值对。该方法在基类中提供。

有了以上几个方法我们就可以对 .properties 文件进行操作了！

三．代码实例

package configuration;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Properties;

/** *//**

 * 读取properties文件

 * @author Qutr

 *

 */

public class Configuration

...{

    private Properties propertie;

    private FileInputStream inputFile;

    private FileOutputStream outputFile;

    /** *//**

     * 初始化Configuration类

     */

    public Configuration()

    ...{

        propertie = new Properties();

    }

    /** *//**

     * 初始化Configuration类

     * @param filePath 要读取的配置文件的路径+名称

     */

    public Configuration(String filePath)

    ...{

        propertie = new Properties();

        try ...{

            inputFile = new FileInputStream(filePath);

            propertie.load(inputFile);

            inputFile.close();

        } catch (FileNotFoundException ex) ...{

            System.out.println("读取属性文件--->失败！- 原因：文件路径错误或者文件不存在");

            ex.printStackTrace();

        } catch (IOException ex) ...{

            System.out.println("装载文件--->失败!");

            ex.printStackTrace();

        }

    }//end ReadConfigInfo(...)

    /** *//**

     * 重载函数，得到key的值

     * @param key 取得其值的键

     * @return key的值

     */

    public String getValue(String key)

    ...{

        if(propertie.containsKey(key))...{

            String value = propertie.getProperty(key);//得到某一属性的值

            return value;

        }

        else

            return "";

    }//end getValue(...)

    /** *//**

     * 重载函数，得到key的值

     * @param fileName properties文件的路径+文件名

     * @param key 取得其值的键

     * @return key的值

     */

    public String getValue(String fileName, String key)

    ...{

        try ...{

            String value = "";

            inputFile = new FileInputStream(fileName);

            propertie.load(inputFile);

            inputFile.close();

            if(propertie.containsKey(key))...{

                value = propertie.getProperty(key);

                return value;

            }else

                return value;

        } catch (FileNotFoundException e) ...{

            e.printStackTrace();

            return "";

        } catch (IOException e) ...{

            e.printStackTrace();

            return "";

        } catch (Exception ex) ...{

            ex.printStackTrace();

            return "";

       }

    }//end getValue(...)

    /** *//**

     * 清除properties文件中所有的key和其值

     */

    public void clear()

    ...{

        propertie.clear();

    }//end clear();

    /** *//**

     * 改变或添加一个key的值，当key存在于properties文件中时该key的值被value所代替，

     * 当key不存在时，该key的值是value

     * @param key 要存入的键

     * @param value 要存入的值

     */

    public void setValue(String key, String value)

    ...{

        propertie.setProperty(key, value);

    }//end setValue(...)

    /** *//**

     * 将更改后的文件数据存入指定的文件中，该文件可以事先不存在。

     * @param fileName 文件路径+文件名称

     * @param description 对该文件的描述

     */

    public void saveFile(String fileName, String description)

    ...{

        try ...{

            outputFile = new FileOutputStream(fileName);

            propertie.store(outputFile, description);

            outputFile.close();

        } catch (FileNotFoundException e) ...{

            e.printStackTrace();

        } catch (IOException ioe)...{

            ioe.printStackTrace();

        }

    }//end saveFile(...)

    public static void main(String[] args)

    ...{

        Configuration rc = new Configuration("."config"test.properties");//相对路径

        String ip = rc.getValue("ipp");//以下读取properties文件的值

        String host = rc.getValue("host");

        String tab = rc.getValue("tab");

        System.out.println("ip = " + ip + "ip-test leng = " + "ip-test".length());//以下输出properties读出的值

        System.out.println("ip's length = " + ip.length());

        System.out.println("host = " + host);

        System.out.println("tab = " + tab);

        Configuration cf = new Configuration();

        String ipp = cf.getValue("."config"test.properties", "ip");

        System.out.println("ipp = " + ipp);

//        cf.clear();

        cf.setValue("min", "999");

        cf.setValue("max", "1000");

        cf.saveFile("."config"save.perperties", "test");

//        Configuration saveCf = new Configuration();

//        saveCf.setValue("min", "10");

//        saveCf.setValue("max", "1000");

//        saveCf.saveFile("."config"save.perperties");

    }//end main()

}//end class ReadConfigInfo

四．小结 通过上面的例子不难看出，在Java中操作配置文件是非常简单的。在一个需要用到大量配置信息的模块或系统里，我们有必要封装一个专门的类来共使用。通过最后的main函数调用，相信大家可以看出该类的用法。不足指出希望大家多多指点。

Java properties文件的操作 

----------------------------------------------------

       java中的properties文件是一种配置文件，主要用于表达配置信息，文件类型为*.properties，格式为文本文件，文件的内容是格式是"键=值"的格式，在properties文件中，可以用"#"来作注释，properties文件在Java编程中用到的地方很多，操作很方便。下面是一个操作java properties文件的例子，给出了操作方法和properties文件。从中可以看到如何读取properties文件，并应用读取出来的值，是学习操作properties文件的好例子。

一、properties文件

IcisReport.properties

------------------------------------------------------

#################################

#   工商报表应用IcisReport的配置文件       #

#   作者：雷智民                                              #

#   日期：2006年11月21日                           #

#################################

#

#   说明:业务系统TopIcis和报表系统IcisReport是分离的

#   可分开部署到不同的服务器上，也可以部署到同一个服务

#   器上;IcisReprot作为独立的web应用程序可以使用任何

#   的Servlet容器或者J2EE服务器部署并单独运行，也可以

#   通过业务系统的接口调用作为业务系统的一个库来应用.

#

#   IcisReport的ip

IcisReport.server.ip=192.168.3.143

#   IcisReport的端口

IcisReport.server.port=8080

#   IcisReport的上下文路径

IcisReport.contextPath=/IcisReport

------------------------------------------------------ 

二、操作properties文件的java方法 

下面是一个操作properties文件的方法

    /** *//**

     * @return 获取IcisReport报表应用的URL

     */

    private String getIcisReportURL() ...{

        String icisReportURL = ""; // IcisReport报表应用的URL

        String icisReportServerIP = ""; // IcisReport服务器的IP

        String icisReportServerPort = ""; // IcisReport服务器的服务端口

        String icisReportContextPath = ""; // IcisReport应用的ContextPath

        Properties prop = new Properties();

        InputStream in;

        try ...{

            in = getClass().getResourceAsStream("/IcisReport.properties");

            prop.load(in);

            Set keyValue = prop.keySet();

            for (Iterator it = keyValue.iterator(); it.hasNext();) ...{

                String key = (String) it.next();

                if (key.equals("IcisReport.server.ip")) ...{

                    icisReportServerIP = (String) prop.get(key);

                } else if (key.equals("IcisReport.server.port")) ...{

                    icisReportServerPort = (String) prop.get(key);

                } else if (key.equals("IcisReport.contextPath")) ...{

                    icisReportContextPath = (String) prop.get(key);

                }

            }

        } catch (Exception e) ...{

            log.error("IO读取出错，找不到IcisReport.properties!");

        }

        if (icisReportServerIP.trim().equals("")) ...{

            log

                    .error("请检查配置文件IcisReport.properties中的IcisReport.server.ip项的值是否正确!");

        }

        if (icisReportServerPort.trim().equals("")) ...{

            log

                    .error("请检查配置文件IcisReport.properties中的IcisReport.server.port项的值是否正确!");

        }

        if (icisReportServerPort.trim().equals("")) ...{

            log

                    .error("请检查配置文件IcisReport.properties中的IcisReport.server.port项的值是否正确!");

        }

        icisReportURL = "http://" + icisReportServerIP.trim() + ":"

                + icisReportServerPort.trim() + icisReportContextPath.trim();

       log.info("获取的icisReportURL=" + icisReportURL);

        return icisReportURL;

    }

总结：java的properties文件需要放到classpath下面，这样程序才能读取到，有关classpath实际上就是java类或者库的存放路径，在java工程中，properties放到class文件一块。在web应用中，最简单的方法是放到web应用的WEB-INF"classes目录下即可，也可以放在其他文件夹下面，这时候需要在设置classpath环境变量的时候，将这个文件夹路径加到classpath变量中，这样也也可以读取到。在此，你需要对classpath有个深刻理解，classpath绝非系统中刻意设定的那个系统环境变量，WEB-INF"classes其实也是，java工程的class文件目录也是。

该文章转载自网络大本营：http://www.xrss.cn/Dev/JAVA/200761514149.Html