Java线程简单案列

这里主要介绍了线程的创建的常用两种方式:

(1)通过继承Thread类直接创建线程对象;

(2)通过继承Runnable借口间接创建线程对象;


第一种:通过继承Thread类直接创建线程对象;

第一步:定义一个类继承Thread类;

第二步:重新定义run()方法;

第三步:实例化线程对象;

第四步:结束线程;

public class ThreadDemo {
	
	//线程A
	static class ThreadA extends Thread{
		public int distance;
		
		public void run() {
			distance = 0;
			
			for(int i = 0;i<10;i++){
				distance += 1;
				System.out.println("线程A" +"  "+distance);
				
				try {
					sleep((long) (Math.random() * 1000));//当前线程睡眠随机数产生
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("线程A运行完毕");
			
		}
	}
	
	//线程B
	static class ThreadB extends Thread{
		public int distance;
		
		public void run() {
			distance = 0;
			
			for(int i = 0;i<10;i++){
				distance += 1;
				System.out.println("线程B" +"  "+distance);
				
				try {
					sleep((long) (Math.random() * 1000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("线程B运行完毕");
			
		}
	}
	
	public static void main(String[] args) {
		ThreadA threadA = new ThreadA();
		threadA.start();
		ThreadB threadB = new ThreadB();
		threadB.start();
	}
}


第二种:通过继承Runnable借口间接创建线程对象;

第一步:定义一个类,实现Runnable接口

如下面 static class ThreadA implements Runnable{......}(动态类在静态方法不能实例化,所以加上static)

第二步:重新定义run()方法;(相当于主程序main方法)

第三步:实例化线程对象

第四步:启动线程


public class RunnableDemo {
	
	//线程A
	static class ThreadA implements Runnable{
		public int distance;

		@Override
		public void run() {
			distance = 0;
			for(int i = 0;i < 10;i++){
				distance += 1;
				System.out.println("线程A" + "  " + distance);
				
				try {
					Thread.sleep((long) (Math.random()*1000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.print("线程A运行完毕");
		}
	}
	
	
	//线程B
	static class ThreadB implements Runnable{
		public int distance;
		
		@Override
		public void run() {
			distance =0;
			for(int i = 0;i<10;i++){
				distance += 1;
				System.out.println("线程B" + "  " +distance);
			}
			try {
				Thread.sleep((long) (Math.random()*1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("线程B运行完毕");
		}
	}

	public static void main(String[] args) {
		ThreadA threadA = new ThreadA();
		Thread A = new Thread(threadA);
		A.start();
		
		ThreadB threadB = new ThreadB();
		Thread B = new Thread(threadB);
		B.start();
 }
}



对比创建两种线程的方法

(1)直接继承Thread类的线程,在实例化线程中已存在包含线程体run()方法;

ThreadA threadA = new ThreadA();
		threadA.start();
		ThreadB threadB = new ThreadB();
		threadB.start();

(2)实现Runnable接口的线程创建方法,在一个非线程对象定义一个run()方法,实例化线程对象要调用这个线程体就要与非线程体建立连接。

ThreadA threadA = new ThreadA();
		Thread A = new Thread(threadA);
		A.start();
		
		ThreadB threadB = new ThreadB();
		Thread B = new Thread(threadB);
		B.start();

(3)直接继承Thread类,适用于单重继承,不能再继承其他类;

(4)实现Runnable类,当一个线程继承另一个类时,就只能实现Runnable接口的方法来创建线程。


Java 分布式锁,是指多个进程或服务器之间可以通过共享锁资源,来协调对共享资源的访问,以保证一定的互斥性和顺序性。 下面是一个简单的分布式锁示例: ```java public class DistributedLock { private static final String LOCK_PATH = "/distributed-lock"; private CuratorFramework client; private InterProcessMutex lock; public DistributedLock(CuratorFramework client) { this.client = client; this.lock = new InterProcessMutex(client, LOCK_PATH); } public boolean acquire() throws Exception { return lock.acquire(5, TimeUnit.SECONDS); } public void release() throws Exception { lock.release(); } } ``` 这里使用了 Apache Curator 框架提供的 InterProcessMutex 分布式锁实现。在 CuratorFramework 实例化时,需要指定 ZooKeeper 的连接信息。 接着在 acquire() 方法中,调用 lock.acquire() 方法获取锁,该方法会阻塞直到获取到锁或者超时。release() 方法则是释放锁,如果当前线程没有持有锁,则抛出 IllegalMonitorStateException 异常。 使用分布式锁的代码示例如下: ```java public void doSomething() throws Exception { DistributedLock lock = new DistributedLock(client); try { if (lock.acquire()) { // 获取到锁,执行业务逻辑 // ... } else { // 获取锁失败,执行其他逻辑 // ... } } catch (Exception e) { // 异常处理 } finally { lock.release(); } } ``` 在业务逻辑中,先实例化 DistributedLock 对象,然后调用 acquire() 方法获取锁。如果获取到了锁,则执行业务逻辑;否则执行其他逻辑。无论如何都要在 finally 块中调用 release() 方法释放锁。 需要注意的是,分布式锁的实现必须要考虑以下问题: 1. 锁的唯一性:多个进程或服务器之间必须共享同一个锁资源,否则无法达到互斥的目的。 2. 锁的可重入性:同一个线程可以多次获取同一个锁,而不会出现死锁等问题。 3. 锁的超时机制:获取锁的操作必须要有超时机制,否则可能会一直等待下去。 4. 锁的容错性:在锁的释放过程中,如果服务器崩溃等异常情况,必须要有容错机制,确保锁能够被释放。 5. 锁的性能问题:锁的实现需要考虑高并发场景下的性能问题,避免出现瓶颈。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值