访问共享变量

启动四个线程，两个线程对i加1，两个线程对i减1。

如果多个线程共享同一个变量，且对变量的操作相同，则可以通过实现Runnable接口实现

为简单起见，对方法进行同步，而不是对操作共享变量的代码块同步

public class Main {

	public static void main(String[] args) {
		Runnable r=new MyRun();
		Thread t1=new Thread(r);
		Thread t2=new Thread(r);
		Thread t3=new Thread(r);
		t1.start();
		t2.start();
		t3.start();
	}
}

class MyRun implements Runnable {
	int i = 0;
	public synchronized void run() {
		i++;
		System.out.println(Thread.currentThread().getName() + ":"+ i);
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

如果多个线程对共享变量操作，且对变量的操作不同，如题所述，两个线程对变量加，两个线程对变量减，则不能用上面的方式。可以使用内部类实现，若使用静态内部类，则只能共享外部类静态变量，若使用非静态内部类，则可以共享外部类的成员变量和静态变量

public class Main5 {

    int i = 0;

    public static void main(String[] args) {
        Main5 m = new Main5();
        Thread t1 = new Thread(m.new MyThread(true));
        Thread t2 = new Thread(m.new MyThread(true));
        Thread t3 = new Thread(m.new MyThread(false));
        Thread t4 = new Thread(m.new MyThread(false));
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

    public class MyThread implements Runnable {
        boolean add;

        public MyThread(boolean add) {
            this.add = add;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (MyThread.class) {//确保每个线程共用同一个锁
                    if (add) {
                        i++;
                        System.out.println(Thread.currentThread().getName()
                                + ":" + i);
                    } else {
                        i--;
                        System.out.println(Thread.currentThread().getName()
                                + ":" + i);
                    }
                }
            }
        }
    }
}

若不使用静态内部类，则可以把共享变量当线程类的成员变量，创建线程对象的时候把共享变量当参数传递进去

public class Main {
	public static void main(String[] args) {
		Num i = new Num(0);
		Mythread1 t1 = new Mythread1(i,true);
		Mythread1 t2 = new Mythread1(i,true);
		Mythread1 t3 = new Mythread1(i,false);
		Mythread1 t4 = new Mythread1(i,false);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

class Mythread1 extends Thread {
	Num num;
	boolean add;

	public Mythread1(Num num,boolean add) {
		this.num = num;
		this.add=add;
	}

	public void run() {
		while (true) {
			synchronized (num) {
				if (add)
					num.i++;
				else
					num.i--;
				System.out.println(Thread.currentThread().getName() + ":" + num.i);
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class Num {
	int i;

	public Num(int i) {
		this.i = i;
	}
}

注意，上述代码中的Num对象，不可直接用Integer对象，因为Integer是不可变类，给构造器传参是传递引用值，修改形参所引用的对象，并不能修改原始变量引用的对象。而新创建的Num类是可变类，可以直接修改Num的成员变量，而没有改变形参引用值。