Thread、Runnable、synchronized关键字

最新推荐文章于 2023-07-25 10:43:31 发布

ZeWe

最新推荐文章于 2023-07-25 10:43:31 发布

阅读量427

点赞数 1

分类专栏：多线程学习文章标签：线程 Thread Runnable synchronized

本文链接：https://blog.csdn.net/SHIYUN123zw/article/details/80043710

版权

多线程学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Thread与RunRunnable实现线程的区别

/**
 * <p>Thread与RunRunnable</P>
 * 
 * @author 
 *
 */

/*
 * 实现Runnable接口
 */
class ImpRunnable implements Runnable{
	
	private int count = 1;

	@Override
	public void run() {
		
		System.out.println(Thread.currentThread().getName()+" : "+(count++));
		
	}
	
}
/**
* 继承Thread
*/
class ExtThread extends Thread{
	
	private int count = 1;
	
	@Override
	public void run() {
		
		System.out.println(Thread.currentThread().getName()+" : "+(count++));

	}
}

public class ThreadDemo {
	
	public static void main(String[] args) throws Exception {
		
		/*
		 * 多线程共享一个对象
		 * 共享imp对象的run方法
		 */
		ImpRunnable imp = new ImpRunnable();								
		Thread t1 = new Thread(imp);
		t1.start();
		Thread.sleep(1000);
		Thread t2 = new Thread(imp);
		t2.start();
		Thread.sleep(1000);
		Thread t3 = new Thread(imp);
		t3.start();
		Thread.sleep(1000);
		System.out.println("---------------------------------");
		
		/**
		 * 每个线程都是一个实例，使用自己的run方法
		 */
		ExtThread t4 = new ExtThread();
		t4.start();
		Thread.sleep(1000);
		ExtThread t5 = new ExtThread();
		t5.start();
		Thread.sleep(1000);
		ExtThread t6 = new ExtThread();
		t6.start();
		Thread.sleep(1000);
		System.out.println("---------------------------------");
		
		/**
		 * 一个线程使用一个对象，所以结果与ExtThread一致
		 */
		Thread t7 = new Thread(new ImpRunnable());
		t7.start();
		Thread.sleep(1000);
		Thread t8 = new Thread(new ImpRunnable());
		t8.start();
		Thread.sleep(1000);
	}
	

}

/**
 *  结果：
 *  
 *	Thread-0 : 1
	Thread-1 : 2
	Thread-2 : 3
	---------------------------------
	Thread-3 : 1
	Thread-4 : 1
	Thread-5 : 1
	---------------------------------
	Thread-6 : 1
	Thread-7 : 1
 *
 *  实现Runnable接口，可以只创建一个类的实例，而且可以被多个线程共享。
 *  而继承Thread类，必须为每一个线程创建不同的实例。因此每个类的实例分配了不同的内存空间，每一个都Count=1开始。
 *
 *
 */

Synchronized关键字

/**
 * <p>synchronized关键字锁住本身</p>
 * 
 */


class SyncThread implements Runnable{
	
	private static int count = 0; 
	
	@Override
	public  void run() {
		
		//给对象上锁
		/*synchronized (this) {
			 for (int i = 0; i < 5; i++) {
		            try {
		               System.out.println(Thread.currentThread().getName() + ":" + (count++));
		               Thread.sleep(100);
		            } catch (InterruptedException e) {
		               e.printStackTrace();
		            }
		     }
		 }*/
		
		   method();
	   }	
        
		//修饰方法效果与上一致
	    public synchronized void method() {
	    	
	    	 for (int i = 0; i < 5; i++) {
		            try {
		               System.out.println(Thread.currentThread().getName() + ":" + (count++));
		               Thread.sleep(100);
		            } catch (InterruptedException e) {
		               e.printStackTrace();
		            }
		     }
	    }
	
}
public class SyncThreadDemo1{
	
	  public static void main(String[] args) {
		  
		    SyncThread syt1 = new SyncThread();
			//SyncThread syt2 = new SyncThread();
			
			Thread t1 = new Thread(syt1,"t1");
			Thread t2 = new Thread(syt1,"t2");
			
			t1.start();
			t2.start();
		
	  }
	
	
}

/**
 * 未加synchronized
	t2:0
	t1:1
	t1:2
	t2:3
	t2:4
	t1:5
	t1:6
	t2:7
	t1:8
	t2:9
	
      加synchronized(this)
	t2:0
	t2:1
	t2:2
	t2:3
	t2:4
	t1:5
	t1:6
	t1:7
	t1:8
	t1:9
	
	当两个并发线程(t1和t2)访问同一个对象(syncThread)中的synchronized代码块时，
	在同一时刻只能有一个线程得到执行，另一个线程受阻塞，
	必须等待当前线程执行完这个代码块以后才能执行该代码块。t1和t2是互斥的，
	因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，
	下一个线程才能执行并锁定该对象。 
	
	
	写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，都是锁定了整个方法时的内容。

    synchronized关键字不能继承。 
        虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，
        因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，
        而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，
        而必须显式地在子类的这个方法中加上synchronized关键字才可以。
        当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，
        但子类调用了父类的同步方法(super.method();)，因此，子类的方法也就相当于同步了。
 * 
 */

/**
 * <p>synchronized关键字锁住对象</p>
 * 
 *
 */

class Counter {
	private Integer count;
	public Counter(Integer count) {
		this.count = count; 
	}
	
	public void add() {
		count+=50;
	}
	
	public void sub() {
		count-=50;
	}
	
	public Integer getCount() {
		return count;
	}
	
}

class CountOperator implements Runnable{
	
	private Counter counter;
	
	public CountOperator(Counter counter) {
		this.counter = counter;
	}

	@Override
	public void run() {
		
		synchronized (counter) {
			counter.add();
			try {
				//故意等1秒
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			counter.sub();
			System.out.println(Thread.currentThread().getName() + ":" + counter.getCount());
		}
	}
	
}

public class SyncThreadDemo2 {
	
	public static void main(String[] args) {
		Counter count = new Counter(100);
		
		CountOperator co = new CountOperator(count);
		
		/**
		 * 5个线程共享  co
		 */
		Thread t1 = new Thread(co);
		Thread t2 = new Thread(co);
		Thread t3 = new Thread(co);
		Thread t4 = new Thread(co);
		Thread t5 = new Thread(co);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		
	}

}

/**

结果：

Thread-1:100
Thread-3:100
Thread-4:100
Thread-0:100
Thread-2:100

------------------------------------------------------------
5个线程共享 CountOperator 类中的run方法里，我们用synchronized 给counter对象加了锁。
这时，当一个线程访问counter对象时，其他试图访问counter对象的线程将会阻塞，
直到该线程访问counter对象结束。
也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。 
*/

/**
 * <p>Synchronized修饰一个静态方法</p>
 * 
 *
 */

class SyncThread1 implements Runnable{
	
	private static int count = 0;
	
	public static synchronized void method() {
    	
	   	 for (int i = 0; i < 5; i++) {
		            try {
		               System.out.println(Thread.currentThread().getName() + ":" + (count++));
		               Thread.sleep(100);
		            } catch (InterruptedException e) {
		               e.printStackTrace();
		            }
		     }
   }

	@Override
	public void run() {
		
		method();
	}
	
}

public class SyncThreadDemo3 {
      
	public static void main(String[] args) {
		
		SyncThread1 syt1 = new SyncThread1();
		SyncThread1 syt2 = new SyncThread1();
		
		Thread t1 = new Thread(syt1,"t1");
		Thread t2 = new Thread(syt2,"t2");
		
		t1.start();
		t2.start();
	}
}

/**
 * 
 * 
 * syncThread1和syncThread2是SyncThread的两个对象，但在t1和t2并发执行时却保持了线程同步。
 * 这是因为run中调用了静态方法method，
 * 而静态方法是属于类的，
 * 所以syncThread1和syncThread2相当于用了同一把锁
 * 
 * 
 * 
 * 
 * 
 * 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 
      每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
 * 
 * 
 * 
 * 
 * 
 * 
 * */