Thread、Runnable、synchronized关键字

最新推荐文章于 2021-08-21 16:21:56 发布
最新推荐文章于 2021-08-21 16:21:56 发布
阅读量396 收藏 1
点赞数 1
分类专栏： 多线程学习 文章标签： 线程 Thread Runnable synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SHIYUN123zw/article/details/80043710
版权

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）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
 * 
 * 
 * 
 * 
 * 
 * 
 * */

ZeWe
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面试题（线程和JSP及EJB部分）.pdf
04-25
答：有两种实现方法，分别是继承Thread类与实现Runnable 接口 用synchronized 关键字修饰同步方法 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线 程...
java 多线程 Thread、Runnable、synchronized
超级大洋葱的博客
01-16 300
文章目录1. 多线程概述2. 线程实现一：继承Thread类3. 线程实现二:实现Runnable接口4. synchronized 同步代码块5. 同步方法6. 线程生命周期图 1. 多线程概述 学习多线程之前，我们先要了解几个关于多线程有关的概念。 A:进程： 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。 B:线程： 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的
Java基础语法之多线程_Thread_Runnable_同步代码块synchronized_优化_wait_notify_Lock锁_线程池_线程组
weixin_44956898的博客
08-21 352
文章目录1.方式1Thread类1.Thread类的方法2.方法1）join2）yield3）setDaemon2.方式2Runnable1.多线程的实现方式2步骤4.synchronizeda）同步代码块b）同步方法5.优化a）死锁a）优化1b）优化2 wait()+notify()6.Lock锁7.线程组（了解）8.线程池（重点） 线程 线程是依赖于进程的 进程: 能够调用的系统资源的独立单位! 理解:计算机---->打开任务管理器---->客户端软件-
Java技能点--Runnable接口与synchronized
程序员大阳
10-23 3617
一，概述通过Runable接口实现多线程比继承Thread接口要更实用一些，起码不会占用单继承的名额。在实现多线程时，还是需要注意同步的问题，下面一个具体的例子。二，简单的Runnable接口实现多线程例子本例子模拟了访客访问网站这个事情。package org.maoge.thread; //通过Runnable接口实现多线程 public class RunnableDemo implement
多线程runnable 和 synchronized
anelmanager的专栏——我只是个新手而已
07-07 494
只要是new一个共享资源就行 runnable （new一个ticket，因为多个线程可以使用一个目标对象） package ticketThread; class ticketP { int ticket=100; void sale() { this.ticket--; } } class ticket extends Thread { private ticketP
Java线程同步之synchronized关键字
Wayfreem的博客
04-01 366
线程安全问题 关于线程安全问题，就是指在高并发的情况下多个线程操作同一个资源的时候，就会出现该资源被多次修改导致出现与预期不一致的结果。 为了处理这种问题，就必须使用同步，所谓同步就是指多个操作在同一个时间段内只能又一个线程线程进行，其他线程要等待此线程完成之后才可以继续执行。需要使用到 synchronized 关键字。 synchronized关键字 关键字 synchronized 有两种用...
java高并发相关知识点.docx
06-26
锁：Java中的锁机制，包括synchronized关键字和ReentrantLock类。 线程池：Java中的线程池机制，包括线程池的创建、执行任务、关闭等操作。 并发集合：Java中的并发集合，包括ConcurrentHashMap、...
java并发编程：线程基础
08-09
线程的创建： 详细讲解线程的创建方式，包括继承 Thread 类和实现 Runnable 接口。演示如何通过这些方式来创建和启动线程。 线程的生命周期： 解释线程的生命周期，包括新建、就绪、运行、阻塞和终止等状态。探讨...
Java高并发精讲（云盘下载）
10-16
一、多线程的基本知识 1.1进程与线程的介绍 　程序运行时在内存中分配自己独立的运行空间，就是进程 　线程：它是位于进程中，负责当前进程中的某个具备独立运行资格的...1.4 JAVA同步 synchronized关键字 ......
java笔试题大集合及答案（另附各大公司笔试题）
06-22
用synchronized关键字修饰同步方法 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。...
Runnable 存在的意义 及 Volatile关键字的主要作用
Gavin_周的博客
04-15 548
Runnable 存在的意义 及 Volatile关键字的主要作用 前言： 平时我们在使用多线程时，常用的方法会有以下三种： 继承 Thread 实现 Runnable 实现Callable 翻开 Thread 源码： public class Thread implements Runnable { /* Make sure registerNatives is the first ...
Java多线程Runnable接口与Thread类，以及synchronied关键字
sunmk
03-31 446
Java多线程实现有两种方式一个是实现Runnable接口一个是继承Thread类 如果只是为了实现Thread的执行过程，那么没有必要从Thread中派生，因为是是实现Runnable接口的对象代表的是一个计算任务，Thread类对应任务的执行者。 如果线程类继承Thread类，则不能继承其他类，而实现Runnable接口没有这个问题。 Thread类有很多实用的方法，例如获得线程的ID，
多线程-线程方法相同/不同下runnable使用 synchronized使用位置 购票
后知后觉的it路
10-18 150
      关于火车票案例中 synchronized放在代码哪里的解释：           案例1： 火车票案例   特点： 多窗口下执行的同一个操作动作，使用的同一个公共数据，使用同一个runnable对象   package thread; public class RunnableInUse { /** * 1 业务类传递给 runnabl...
十七、Java多线程（synchronized关键字、Thread类、Runnable接口）
LOST JACK
09-06 172
synchronized方法的实现 代码 public class Test2 implements Runnable{ private int num=50; private String name; public Test2(String name) { this.name=name; } //同步方法 public synchronized void show() ...
多线程 计算 1+2+3+4+.....+n 的值 — CountDownLatch
ZeWe的博客
06-10 3432
CountDownLatch ：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用给定的计数初始化CountDownLatch。调用countDown()使当前计数减1，在到达0之前，await方法会一直受阻塞。之后，会释放所有等待的线程，await的所有后续调用都将立即返回。 如一个任务A，它要等待其他N个任务执行完毕之后才能执行,则可...
多线程 计算 1+2+3+4+.....+n 的值 — CyclicBarrier
ZeWe的博客
06-11 2254
CyclicBarrier一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)后，在全部同时执行。 所有的线程调用await()方法之后，到达某个公共屏障点。 然后同时执行 await() 后的操作。 public CyclicBarrier(int parties, Runnable barrierAction) { } pub...
使用Socket模拟简易Web服务器
ZeWe的博客
11-18 1531
Web服务器大家应该都很熟悉了，web服务器的原理可以看这里。讲的挺详细的。 本篇主要是模拟一下简单的交互，通过socket通道，浏览器发送请求，服务器返回资源。 简单图例如上，然后来看代码吧   1、首先启动服务监听端口，使用线程池来完成交互 package server; import java.net.ServerSocket; import java.net.Socket...
Lock + Condition 2个例子
ZeWe的博客
10-14 526
1、自定义有边界的队列 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class MyQueue&lt;E&gt; { private Object[] ...
线程定时任务
ZeWe的博客
09-14 461
最近有遇到定时任务的场景，本来想直接整个quartz，但是小场景不用大动作，就网上搜搜博客，摘了几个好的试了试,都挺好使。简单记录下学习学习.   1、Thread + sleep 最简单实现 class ThreadTask extends Thread{ public void run() { while(true) { try { // to ...
java synchronized编程题
最新发布
09-09
在Java中，使用synchronized关键字可以实现线程同步，解决脏数据的问题。通过在方法声明中加上synchronized关键字，可以保证多个线程在执行这个方法时的互斥性，即同一时间只有一个线程可以进入该方法进行操作。这样可以避免多个线程同时对共享数据进行修改而导致数据不一致的问题。 下面是一个示例代码： ```java public class MyThread implements Runnable { private int count; public synchronized void run() { for (int i = 0; i < 5; i++) { count++; System.out.println("线程" + Thread.currentThread().getName() + "，count：" + count); } } public static void main(String[] args) { MyThread myThread = new MyThread(); Thread thread1 = new Thread(myThread, "Thread1"); Thread thread2 = new Thread(myThread, "Thread2"); thread1.start(); thread2.start(); } } ``` 在上述代码中，MyThread类实现了Runnable接口，并重写了run方法，并在run方法声明中加上了synchronized关键字。通过创建两个线程Thread1和Thread2，并启动这两个线程，我们可以看到两个线程交替执行，保证了count的修改操作的原子性。 需要注意的是，synchronized关键字可以修饰方法、代码块和静态方法，用法有所区别。在本例中我们展示了修饰方法的用法。 除了使用synchronized关键字，还有其他的线程同步方式，如Lock和Semaphore等。但synchronized关键字是最常用且简单的一种方式。可以根据具体需求和场景进行选择和使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值