玩转java多线程学习篇二实例变量与线程安全

拼搏现实的明天。 2022-06-16 01:57 173阅读 0赞

一实例变量

前言：自定义线程类中实例变量对其他线程有共享与不共享之分。

1，不共享数据例子：

public class MyThread  extends Thread{
    	 private int count = 8;
    	public MyThread(String name) {
    		// TODO Auto-generated constructor stub
    		this.setName(name);//设置自定义多线程名称
    	}
    	@Override
    	public void run() {
    		super.run();
    		while (count>0) {
    			count--;
    			System.out.println(""+this.currentThread().getName()+","+count);
    		}
    	}
    }

public class threadTest {
    	public static void main(String[] args) {
    		MyThread myThreadA = new MyThread("A");
    		MyThread myThreadB = new MyThread("B");
    		MyThread myThreadC = new MyThread("C");
    		myThreadA.start();
    		myThreadB.start();
    		myThreadC.start();
    	}
    }

2，共享数据例子：

5个销售员，每个销售员卖出去一个货品后不可以得出相同的剩余数量，必须在每一个销售员卖完一个货品后其他销售员才可以在新的剩余物品数量上继续减去一个，这时候需要

使用多个线程之间进行同步。

未同步例子：

public class MyThread  extends Thread{
    	private int count = 8;
    	@Override
    	public void run() {
    		super.run();
    		count--;
    		System.out.println(""+this.currentThread().getName()+","+count);
    	}
    }

public class threadTest {
    	public static void main(String[] args) {
    		MyThread myThread = new MyThread();
    		Thread aThread = new Thread(myThread,"A");
    		Thread bThread = new Thread(myThread,"B");
    		Thread cThread = new Thread(myThread,"C");
    
    		aThread.start();
    		bThread.start();
    		cThread.start();
    	}
    }

关键代码加上同步锁，多个线程同时访问情况下，如果多个线程同时访问，那么一定会出现非线程安全问题。加锁的这段代码称为“互斥区”和“临界区”。

非线程安全：指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被修改或不同步的情况。

public class MyThread  extends Thread{
    	private int count = 8;
    	@Override
    	synchronized public void run() {
    		super.run();
    		count--;
    		System.out.println(""+this.currentThread().getName()+","+count);
    	}
    }

当一个线程A调用run前，先判断run方法是否上锁，如果上锁，其它线程正在使用run方法，那么线程A就会等待其它线程执行完再执行。

synchronized 关键字可以在任意对象及方法上加锁。

3，println和i-- 的非线程安全问题

println源码

/**
         * Prints a String and then terminate the line.  This method behaves as
         * though it invokes <code>{@link #print(String)}</code> and then
         * <code>{@link #println()}</code>.
         *
         * @param x  The <code>String</code> to be printed.
         */
        public void println(String x) {
            synchronized (this) {
                print(x);
                newLine();
            }
        }

public class MyThread  extends Thread{
    	private int i = 8;
    	@Override
    	public void run() {
    		super.run();
    		System.out.println("i="+ (i--) + "name:"+Thread.currentThread().getName());
    	}
    }

public class threadTest {
    	public static void main(String[] args) {
    		MyThread myThread = new MyThread();
    		Thread aThread = new Thread(myThread);
    		Thread bThread = new Thread(myThread);
    		Thread cThread = new Thread(myThread);
    		Thread dThread = new Thread(myThread);
    		Thread eThread = new Thread(myThread);
    		Thread fThread = new Thread(myThread);
    
    		aThread.start();
    		bThread.start();
    		cThread.start();
    		dThread.start();
    		eThread.start();
    		fThread.start();
    	}
    }