访问共享变量

最新推荐文章于 2025-06-26 08:49:48 发布

原创最新推荐文章于 2025-06-26 08:49:48 发布 · 638 阅读

0 ·

CC 4.0 BY-SA版权

java 同时被 2 个专栏收录

12 篇文章

订阅专栏

多线程

1 篇文章

订阅专栏

本文介绍如何在Java中通过实现Runnable接口来创建线程，并演示了使用同步方法和锁来协调多个线程对共享变量进行加减操作的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

启动四个线程，两个线程对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的成员变量，而没有改变形参引用值。