Java线程基础、线程之间的共享和协作

最新推荐文章于 2022-09-07 23:49:40 发布
最新推荐文章于 2022-09-07 23:49:40 发布
阅读量579 收藏 1
点赞数
分类专栏： Java并发编程 文章标签： java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongxue8888/article/details/104405947
版权

文章目录

基础概念

  • CPU核心数和线程数的关系
    核心数:线程数=1:1 ;使用了超线程技术后—> 1:2

  • CPU时间片轮转机制
    又称RR调度，会导致上下文切换

  • 什么是进程和线程

    • 进程：程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源
    • 线程：CPU调度的最小单位，必须依赖进程而存在。

  • 澄清并行和并发

    • 并行：同一时刻，可以同时处理事情的能力
    • 并发：与单位时间相关，在单位时间内可以处理事情的能力

  • 高并发编程的意义、好处和注意事项

    • 好处：充分利用cpu的资源、加快用户响应的时间，程序模块化，异步化
    • 问题：
      线程共享资源，存在冲突；
      容易导致死锁；
      启用太多的线程，就有搞垮机器的可能

认识Java里的线程

java的多线程无处不在

/**
 *类说明：java的多线程无处不在
 */
public class OnlyMain {
    public static void main(String[] args) {
    	//虚拟机线程管理的接口
    	ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    	ThreadInfo[] threadInfos = 
    	 threadMXBean.dumpAllThreads(false, false);
    	for(ThreadInfo threadInfo:threadInfos) {
    		System.out.println("["+threadInfo.getThreadId()+"]"+" "
    				+threadInfo.getThreadName());
    	}
    }
}

输出：

[4] Signal Dispatcher
[3] Finalizer
[2] Reference Handler
[1] main

新启线程的方式三种

新启线程的方式三种：

  • 类Thread
  • 接口Runnable
  • 接口Callable
/**
 * 类说明：如何新建线程
 */
public class NewThread {
	/* 扩展自Thread类 */
	/* 实现Runnable接口 */
	private static class UseRun implements Runnable {
		@Override
		public void run() {
			System.out.println("I am implements Runnable");
		}
	}
	/* 实现Callable接口，允许有返回值 */
	private static class UseCall implements Callable<String> {
		@Override
		public String call() throws Exception {
			System.out.println("I am implements Callable");
			return "CallResult";
		}
	}
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		UseRun useRun = new UseRun();
		new Thread(useRun).start();

		UseCall useCall = new UseCall();
		FutureTask<String> futureTask = new FutureTask<>(useCall);
		new Thread(futureTask).start();
		System.out.println(futureTask.get());
	}
}

打印：

I am implements Runnable
I am implements Callable
CallResult

线程安全停止工作

怎么样才能让Java里的线程安全停止工作呢？

stop()还是interrupt() 、 isInterrupted()、static方法interrupted()，深入理解这些方法

  • 线程自然终止：自然执行完或抛出未处理异常

  • stop()，resume(),suspend()已不建议使用，stop()会导致线程不会正确释放资源，suspend()容易导致死锁。

  • java线程是协作式，而非抢占式。调用一个线程的interrupt() 方法中断一个线程，并不是强行关闭这个线程，只是跟这个线程打个招呼，将线程的中断标志位置为true，线程是否中断，由线程本身决定。

  • isInterrupted() 判定当前线程是否处于中断状态。

  • static方法interrupted() 判定当前线程是否处于中断状态，同时中断标志位改为false。

/**
 * 类说明：如何安全的中断线程
 */
public class EndThread {
	private static class UseThread extends Thread {
		public UseThread(String name) {
			super(name);
		}
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			while (!isInterrupted()) {
				System.out.println(threadName + " is run!");
			}
			System.out.println(threadName + " interrput flag is " + isInterrupted());
		}
	}
	public static void main(String[] args) throws InterruptedException {
		Thread endThread = new UseThread("endThread");
		endThread.start();
		Thread.sleep(2);
		endThread.interrupt();
	}
}

打印：

…
endThread is run!
endThread is run!
endThread is run!
endThread interrput flag is true

		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			while (true) {
				System.out.println(threadName + " is run!");
			}
//			System.out.println(threadName + " interrput flag is " + isInterrupted());
		}

如果我们不在run方法中做处理，即使调用了interrupt方法，子线程是不会停止的。

/**
 *   类说明：中断Runnable类型的线程
 */
public class EndRunnable {
	private static class UseRunnable implements Runnable {
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			while (!Thread.currentThread().isInterrupted()) {
				System.out.println(threadName + " is run!");
			}
			System.out.println(threadName + " interrput flag is " + Thread.currentThread().isInterrupted());
		}
	}
	public static void main(String[] args) throws InterruptedException {
		UseRunnable useRunnable = new UseRunnable();
		Thread endThread = new Thread(useRunnable, "endThread");
		endThread.start();
		Thread.sleep(1);
		endThread.interrupt();
	}
}

打印：

…
endThread is run!
endThread is run!
endThread interrput flag is true


方法里如果抛出InterruptedException，线程的中断标志位会被复位成false，如果确实是需要中断线程，要求我们自己在catch语句块里再次调用interrupt()。

/**
 * 类说明：抛出InterruptedException异常的时候，要注意中断标志位
 */
public class HasInterrputException {
	private static class UseThread extends Thread {
		public UseThread(String name) {
			super(name);
		}
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			while (!isInterrupted()) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					System.out.println(threadName + " catch interrput flag is " + isInterrupted());
					e.printStackTrace();
				}
				System.out.println(threadName);
			}
			System.out.println(threadName + " interrput flag is " + isInterrupted());
		}
	}
	public static void main(String[] args) throws InterruptedException {
		Thread endThread = new UseThread("HasInterrputEx");
		endThread.start();
		Thread.sleep(20);
		endThread.interrupt();
	}
}

打印：
在这里插入图片描述
在catch语句块里再次调用interrupt()：
在这里插入图片描述
打印：
在这里插入图片描述

对Java里的线程再多一点点认识

线程常用方法和线程的状态

参考：线程的状态详解
在这里插入图片描述

线程只有5种状态。整个生命周期就是这几种状态的切换。

  • run()和start() ：run方法就是普通对象的普通方法，只有调用了start()后，Java才会将线程对象和操作系统中实际的线程进行映射，再来执行run方法。

  • yield() ：让出cpu的执行权，将线程从运行转到可运行状态，但是下个时间片，该线程依然有可能被再次选中运行。

深入理解run()和start()：

/**
 *类说明：start和run方法的区别
 */
public class StartAndRun {
    public static class ThreadRun extends Thread{
        @Override
        public void run() {
            int i = 90;
            while(i>0){
            	try {
					sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
                System.out.println("I am "+Thread.currentThread().getName()
                		+" and now the i="+i--);
            }
        }
    }
    public static void main(String[] args) {
    	ThreadRun beCalled = new ThreadRun();
    	beCalled.setName("BeCalled");
    	//beCalled.setPriority(newPriority);
    	beCalled.start();
//    	beCalled.run();
    }
}

打印：

I am BeCalled and now the i=90
I am BeCalled and now the i=89
I am BeCalled and now the i=88
I am BeCalled and now the i=87
I am BeCalled and now the i=86
I am BeCalled and now the i=85
I am BeCalled and now the i=84
…

如果是beCalled.run() ，则打印：

I am main and now the i=90
I am main and now the i=89
I am main and now the i=88
I am main and now the i=87
I am main and now the i=86
I am main and now the i=85
I am main and now the i=84
…

线程的优先级

取值为1~10，缺省为5，但线程的优先级不可靠，不建议作为线程开发时候的手段。

setPriority 方法用于设置线程的优先级。每个线程都有自己的优先级数值，当 CPU 资源紧张的时候，优先级高的线程获得 CPU 资源的概率会更大。请注意仅仅是概率会更大，并不意味着就一定能够先于优先级低的获取。这和摇车牌号一个道理，我现在中签概率是标准的 9 倍，但摇中依然摇摇无期。而身边却时不时的出现第一次摇号就中的朋友。如果在 CPU 比较空闲的时候，那么优先级就没有用了，人人都有肉吃，不需要摇号了。

优先级别高可以在大量的执行中有所体现。在大量数据的样本中，优先级高的线程会被选中执行的次数更多。

Thread 有自己的最小和最大优先级数值，范围在 1-10。如果不在此范围内，则会报错。另外如果设置的 priority 超过了线程所在组的 priority ，那么只能被设置为组的最高 priority 。最后通过调用 native 方法 setPriority0 进行设置。

守护线程

当 JVM 中没有任何一个非守护线程时，所有的守护线程都会进入到 TERMINATED 状态，JVM 退出。

在 Java 中，当没有非守护线程存在时，JVM 就会结束自己的生命周期。而守护进程也会自动退出。守护线程一般用于执行独立的后台业务。比如 JAVA 的垃圾清理就是由守护线程执行。而所有非守护线程都退出了，也没有垃圾回收的需要了，所以守护线程就随着 JVM 关闭一起关闭了。

当你有些工作属于后台工作，并且你希望这个线程自己不会终结，而是随着 JVM 退出时自动关闭，那么就可以选择使用守护线程。

要实现守护线程只能手动设置，在线程 start 前调用 setDaemon 方法。Thread 没有直接创建守护进程的方式，非守护线程创建的子线程都是非守护线程。

和主线程共死，finally不能保证一定执行：

/**
 *   类说明：守护线程的使用和守护线程中的finally语句块
 */
public class DaemonThread {
	private static class UseThread extends Thread {
		@Override
		public void run() {
			try {
				while (!isInterrupted()) {
					System.out.println(Thread.currentThread().getName() + " I am extends Thread.");
				}
				System.out.println(Thread.currentThread().getName() + " interrupt flag is " + isInterrupted());
			} finally {
				System.out.println("...........finally");
			}
		}
	}
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		UseThread useThread = new UseThread();
		useThread.setDaemon(true);
		useThread.start();
		Thread.sleep(1);
//		useThread.interrupt();
	}
}

打印结果并没有执行finally。

线程间的共享

1. synchronized内置锁

对象锁，锁的是类的对象实例。
类锁 ，锁的是每个类的的Class对象，每个类的的Class对象在一个虚拟机中只有一个，所以类锁也只有一个。

对象锁示例：

/**
 * 类说明：演示对象锁和类锁
 */
public class SynClzAndInst {

	// 使用类锁的线程
	private static class SynClass extends Thread {
		@Override
		public void run() {
			System.out.println("TestClass is running...");
			synClass();
		}
	}

	// 使用对象锁的线程
	private static class InstanceSyn implements Runnable {
		private SynClzAndInst synClzAndInst;

		public InstanceSyn(SynClzAndInst synClzAndInst) {
			this.synClzAndInst = synClzAndInst;
		}

		@Override
		public void run() {
			System.out.println("TestInstance is running..." + synClzAndInst);
			synClzAndInst.instance();
		}
	}

	// 使用对象锁的线程
	private static class Instance2Syn implements Runnable {
		private SynClzAndInst synClzAndInst;

		public Instance2Syn(SynClzAndInst synClzAndInst) {
			this.synClzAndInst = synClzAndInst;
		}

		@Override
		public void run() {
			System.out.println("TestInstance2 is running..." + synClzAndInst);
			synClzAndInst.instance2();
		}
	}

	// 锁对象
	private synchronized void instance() {
		SleepTools.second(3);
		System.out.println("synInstance is going..." + this.toString());
		SleepTools.second(3);
		System.out.println("synInstance ended " + this.toString());
	}

	// 锁对象
	private synchronized void instance2() {
		SleepTools.second(3);
		System.out.println("synInstance2 is going..." + this.toString());
		SleepTools.second(3);
		System.out.println("synInstance2 ended " + this.toString());
	}

	// 类锁，实际是锁类的class对象
	private static synchronized void synClass() {
		SleepTools.second(1);
		System.out.println("synClass going...");
		SleepTools.second(1);
		System.out.println("synClass end");
	}

	public static void main(String[] args) {
		SynClzAndInst synClzAndInst = new SynClzAndInst();
		Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
		SynClzAndInst synClzAndInst2 = new SynClzAndInst();
		Thread t2 = new Thread(new Instance2Syn(synClzAndInst2));
		t1.start();
		t2.start();
		SleepTools.second(1);
	}
}

输出：

TestInstance is running…SynClzAndInst@2d3375e
TestInstance2 is running…SynClzAndInst@a2c7b1
synInstance2 is going…SynClzAndInst@a2c7b1
synInstance is going…SynClzAndInst@2d3375e
synInstance2 ended SynClzAndInst@a2c7b1
synInstance ended SynClzAndInst@2d3375e

此时，Instance2Syn和Instance2Syn传入不是同一个对象，instance和instance2方法执行并没有先后顺序。


当Instance2Syn和Instance2Syn传入同一个对象时

	public static void main(String[] args) {
		SynClzAndInst synClzAndInst = new SynClzAndInst();
		Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
//		 SynClzAndInst synClzAndInst2 = new SynClzAndInst();
		Thread t2 = new Thread(new Instance2Syn(synClzAndInst));
		t1.start();
		t2.start();
		SleepTools.second(1);
	}

输出：

TestInstance is running…SynClzAndInst@5c16ceab
TestInstance2 is running…SynClzAndInst@5c16ceab
synInstance is going…SynClzAndInst@5c16ceab
synInstance ended SynClzAndInst@5c16ceab
synInstance2 is going…SynClzAndInst@5c16ceab
synInstance2 ended SynClzAndInst@5c16ceab

此时，两个线程虽然都开启了，但是执行对象synClzAndInst中的instance和instance2方法是有先后顺序的。

类锁示例：

	public static void main(String[] args) {
		SynClzAndInst synClzAndInst = new SynClzAndInst();
		Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
		t1.start();
		SynClass synClass = new SynClass();
		synClass.start();
		SleepTools.second(1);
	}

输出：

TestInstance is running…SynClzAndInst@5c16ceab
TestClass is running…
synClass going…
synClass end
synInstance is going…SynClzAndInst@5c16ceab
synInstance ended SynClzAndInst@5c16ceab

2. volatile关键字

参考：Java并发-Volatile详解
适合于只有一个线程写，多个线程读的场景，因为它只能确保可见性。

演示volatile无法提供操作的原子性：

/**
 * 类说明：演示volatile无法提供操作的原子性
 */
public class VolatileUnsafe {
	private static class VolatileVar implements Runnable {
		private volatile int a = 0;
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			a = a++;
			System.out.println(threadName + ":======" + a);
			SleepTools.ms(100);
			a = a + 1;
			System.out.println(threadName + ":======" + a);
		}
	}
	public static void main(String[] args) {
		VolatileVar v = new VolatileVar();
		Thread t1 = new Thread(v);
		Thread t2 = new Thread(v);
		Thread t3 = new Thread(v);
		Thread t4 = new Thread(v);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

输出：

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

从输出可以看出，volatile无法提供操作的原子性。

3. ThreadLocal

线程变量。可以理解为是个map，类型 Map<Thread,Integer>

/**
 * 类说明：演示ThreadLocal的使用
 */
public class UseThreadLocal {

	// 可以理解为 一个map，类型 Map<Thread,Integer>
	static ThreadLocal<Integer> threadLaocl = new ThreadLocal<Integer>() {
		@Override
		protected Integer initialValue() {
			return 1;
		}
	};

	/**
	 * 运行3个线程
	 */
	public void StartThreadArray() {
		Thread[] runs = new Thread[3];
		for (int i = 0; i < runs.length; i++) {
			runs[i] = new Thread(new TestThread(i));
		}
		for (int i = 0; i < runs.length; i++) {
			runs[i].start();
		}
	}

	/**
	 * 类说明：测试线程，线程的工作是将ThreadLocal变量的值变化，并写回，看看线程之间是否会互相影响
	 */
	public static class TestThread implements Runnable {
		int id;

		public TestThread(int id) {
			this.id = id;
		}

		public void run() {
			System.out.println(Thread.currentThread().getName() + ":start");
			Integer s = threadLaocl.get();// 获得变量的值
			s = s + id;
			threadLaocl.set(s);
			System.out.println(Thread.currentThread().getName() + ":" + threadLaocl.get());
			// threadLaocl.remove();
		}
	}

	public static void main(String[] args) {
		UseThreadLocal test = new UseThreadLocal();
		test.StartThreadArray();
	}
}

Thread-0:start
Thread-2:start
Thread-1:start
Thread-1:2
Thread-0:1
Thread-2:3


线程间协作

轮询：难以保证及时性，资源开销很大

等待和通知

wait() 对象上的方法

notify/notifyAll 对象上的方法

等待和通知的标准范式

等待方：

  1. 获取对象的锁；
  2. 循环里判断条件是否满足，不满足调用wait方法，
  3. 条件满足执行业务逻辑

通知方来说

  1. 获取对象的锁；
  2. 改变条件
  3. 通知所有等待在对象的线程

notify和notifyAll应该用谁？

应该尽量使用notifyAll，使用notify因为有可能发生信号丢失的的情况。

示例：

/**
 * 类说明：快递实体类
 */
public class Express {
	public final static String CITY = "ShangHai";
	private int km;/* 快递运输里程数 */
	private String site;/* 快递到达地点 */
	public Express(int km, String site) {
		this.km = km;
		this.site = site;
	}
	/* 变化公里数，然后通知处于wait状态并需要处理公里数的线程进行业务处理 */
	public synchronized void changeKm() {
		this.km = 101;
		notifyAll();
		// 其他的业务代码
	}
	/* 变化地点，然后通知处于wait状态并需要处理地点的线程进行业务处理 */
	public synchronized void changeSite() {
		this.site = "BeiJing";
		notifyAll();
	}
	public synchronized void waitKm() {
		while (this.km <= 100) {
			try {
				wait();
				System.out.println("check km thread[" 
				+ Thread.currentThread().getId() + "] is be notifed.");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("the km is" 
		+ this.km + ",I will change db.");
	}
	public synchronized void waitSite() {
		while (CITY.equals(this.site)) {
			try {
				wait();
				System.out.println("check site thread[" + Thread.currentThread().getId() + "] is be notifed.");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("the site is" + this.site + ",I will call user.");
	}
}

/**
 *      类说明：测试wait/notify/notifyAll
 */
public class TestWN {
	private static Express express = new Express(0, Express.CITY);
	/* 检查里程数变化的线程,不满足条件，线程一直等待 */
	private static class CheckKm extends Thread {
		@Override
		public void run() {
			express.waitKm();
		}
	}
	/* 检查地点变化的线程,不满足条件，线程一直等待 */
	private static class CheckSite extends Thread {
		@Override
		public void run() {
			express.waitSite();
		}
	}
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 3; i++) {// 三个线程
			new CheckSite().start();
		}
		for (int i = 0; i < 3; i++) {// 里程数的变化
			new CheckKm().start();
		}
		Thread.sleep(1000);
		express.changeKm();// 快递地点变化
	}
}

输出：

check km thread[15] is be notifed.
the km is101,I will change db.
check km thread[14] is be notifed.
the km is101,I will change db.
check km thread[13] is be notifed.
the km is101,I will change db.
check site thread[12] is be notifed.
check site thread[11] is be notifed.
check site thread[10] is be notifed.


如果将changeKm和changeSite方法中notifyAll()都改成notify()，则输出如下：

check site thread[10] is be notifed.


等待超时模式实现一个连接池

假设 等待时间时长为T，当前时间now+T以后超时

long  overtime = now+T;
long remain = T;//等待的持续时间
while(result不满足条件&& remain>0){
	wait(remain);
	remain = overtime – now;//等待剩下的持续时间
}
return result;

示例：

/**
 *类说明：实现了数据库连接的实现
 */
public class SqlConnectImpl implements Connection{
		/*拿一个数据库连接*/
    public static final Connection fetchConnection(){
        return new SqlConnectImpl();
    }
...
	@Override
	public void commit() throws SQLException {
		SleepTools.ms(70);
	}
...
	@Override
	public Statement createStatement() throws SQLException {
		SleepTools.ms(1);
		return null;
	}
...

}

/**
 * 类说明：实现一个数据库的连接池
 */
public class DBPool {
	// 数据库池的容器
	private static LinkedList<Connection> pool = new LinkedList<>();
	public DBPool(int initalSize) {
		if (initalSize > 0) {
			for (int i = 0; i < initalSize; i++) {
				pool.addLast(SqlConnectImpl.fetchConnection());
			}
		}
	}
	// 在mills时间内还拿不到数据库连接，返回一个null
	public Connection fetchConn(long mills) throws InterruptedException {
		synchronized (pool) {
			if (mills < 0) {
				while (pool.isEmpty()) {
					pool.wait();
				}
				return pool.removeFirst();
			} else {
				long overtime = System.currentTimeMillis() + mills;
				long remain = mills;
				while (pool.isEmpty() && remain > 0) {
					pool.wait(remain);
					remain = overtime - System.currentTimeMillis();
				}
				Connection result = null;
				if (!pool.isEmpty()) {
					result = pool.removeFirst();
				}
				return result;
			}
		}
	}
	// 放回数据库连接
	public void releaseConn(Connection conn) {
		if (conn != null) {
			synchronized (pool) {
				pool.addLast(conn);
				pool.notifyAll();
			}
		}
	}
}

/**
 * 类说明：
 */
public class DBPoolTest {
	static DBPool pool = new DBPool(10);
	// 控制器:控制main线程将会等待所有Woker结束后才能继续执行
	static CountDownLatch end;
	public static void main(String[] args) throws Exception {
		// 线程数量
		int threadCount = 50;
		end = new CountDownLatch(threadCount);
		int count = 20;// 每个线程的操作次数
		AtomicInteger got = new AtomicInteger();// 计数器：统计可以拿到连接的线程
		AtomicInteger notGot = new AtomicInteger();// 计数器：统计没有拿到连接的线程
		for (int i = 0; i < threadCount; i++) {
			Thread thread = new Thread(new Worker(count, got, notGot), "worker_" + i);
			thread.start();
		}
		end.await();// main线程在此处等待
		System.out.println("总共尝试了: " + (threadCount * count));
		System.out.println("拿到连接的次数：  " + got);
		System.out.println("没能连接的次数： " + notGot);
	}
	static class Worker implements Runnable {
		int count;
		AtomicInteger got;
		AtomicInteger notGot;
		public Worker(int count, AtomicInteger got, AtomicInteger notGot) {
			this.count = count;
			this.got = got;
			this.notGot = notGot;
		}
		public void run() {
			while (count > 0) {
				try {
					// 从线程池中获取连接，如果1000ms内无法获取到，将会返回null
					// 分别统计连接获取的数量got和未获取到的数量notGot
					Connection connection = pool.fetchConn(1000);
					if (connection != null) {
						try {
							connection.createStatement();
							connection.commit();
						} finally {
							pool.releaseConn(connection);
							got.incrementAndGet();
						}
					} else {
						notGot.incrementAndGet();
						System.out.println(Thread.currentThread().getName() + "等待超时!");
					}
				} catch (Exception ex) {
				} finally {
					count--;
				}
			}
			end.countDown();
		}
	}
}

输出：

worker_22等待超时!
worker_21等待超时!
worker_20等待超时!
worker_38等待超时!
worker_26等待超时!
worker_31等待超时!
worker_11等待超时!
worker_25等待超时!
worker_10等待超时!
worker_17等待超时!
worker_12等待超时!
worker_42等待超时!
worker_37等待超时!
worker_33等待超时!
worker_29等待超时!
worker_18等待超时!
worker_36等待超时!
worker_24等待超时!
worker_16等待超时!
worker_39等待超时!
worker_23等待超时!
worker_19等待超时!
worker_35等待超时!
worker_30等待超时!
worker_14等待超时!
worker_28等待超时!
worker_27等待超时!
worker_34等待超时!
worker_32等待超时!
worker_41等待超时!
worker_40等待超时!
worker_15等待超时!
worker_13等待超时!
worker_2等待超时!
worker_3等待超时!
worker_4等待超时!
worker_5等待超时!
worker_9等待超时!
worker_49等待超时!
worker_47等待超时!
worker_20等待超时!
worker_25等待超时!
worker_11等待超时!
worker_10等待超时!
worker_21等待超时!
worker_26等待超时!
worker_38等待超时!
worker_22等待超时!
worker_31等待超时!
worker_14等待超时!
worker_39等待超时!
worker_17等待超时!
worker_33等待超时!
worker_23等待超时!
worker_19等待超时!
worker_28等待超时!
worker_37等待超时!
worker_29等待超时!
worker_42等待超时!
worker_12等待超时!
worker_36等待超时!
worker_24等待超时!
worker_35等待超时!
worker_16等待超时!
worker_30等待超时!
worker_18等待超时!
worker_34等待超时!
worker_41等待超时!
worker_27等待超时!
worker_32等待超时!
worker_46等待超时!
worker_22等待超时!
worker_28等待超时!
worker_12等待超时!
worker_18等待超时!
worker_42等待超时!
worker_29等待超时!
worker_33等待超时!
worker_17等待超时!
worker_19等待超时!
worker_24等待超时!
worker_25等待超时!
worker_11等待超时!
worker_36等待超时!
worker_35等待超时!
worker_21等待超时!
worker_23等待超时!
worker_39等待超时!
worker_30等待超时!
worker_31等待超时!
worker_34等待超时!
worker_38等待超时!
worker_26等待超时!
worker_10等待超时!
worker_16等待超时!
worker_14等待超时!
worker_26等待超时!
worker_25等待超时!
worker_39等待超时!
worker_11等待超时!
worker_17等待超时!
worker_30等待超时!
worker_34等待超时!
worker_31等待超时!
worker_24等待超时!
worker_19等待超时!
worker_36等待超时!
worker_12等待超时!
worker_23等待超时!
worker_38等待超时!
worker_35等待超时!
worker_21等待超时!
worker_41等待超时!
worker_12等待超时!
worker_23等待超时!
worker_35等待超时!
worker_21等待超时!
worker_19等待超时!
worker_24等待超时!
worker_36等待超时!
worker_38等待超时!
总共尝试了: 1000
拿到连接的次数： 879
没能连接的次数： 121

join()方法

  • 面试点：
    线程A，执行了线程B的join方法，线程A必须要等待B执行完成了以后，线程A才能继续自己的工作

示例：

/**
 * 类说明：演示下join方法的使用
 */
public class UseJoin {
	static class JumpQueue implements Runnable {
		private Thread thread;// 用来插队的线程
		public JumpQueue(Thread thread) {
			this.thread = thread;
		}
		public void run() {
			try {
				System.out.println(thread.getName() + " will be join before " + Thread.currentThread().getName());
				thread.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " terminted.");
		}
	}
	public static void main(String[] args) throws Exception {
		Thread previous = Thread.currentThread();// 现在是主线程
		for (int i = 0; i < 10; i++) {
			// i=0,previous 是主线程，i=1;previous是i=0这个线程
			Thread thread = new Thread(new JumpQueue(previous), String.valueOf(i));
			System.out.println(previous.getName() + " jump a queue the thread:" + thread.getName());
			thread.start();
			previous = thread;
		}
		SleepTools.second(2);// 让主线程休眠2秒
		System.out.println(Thread.currentThread().getName() + " terminate.");
	}
}

输出：

main jump a queue the thread:0
0 jump a queue the thread:1
main will be join before 0
1 jump a queue the thread:2
0 will be join before 1
2 jump a queue the thread:3
1 will be join before 2
3 jump a queue the thread:4
2 will be join before 3
4 jump a queue the thread:5
3 will be join before 4
5 jump a queue the thread:6
4 will be join before 5
6 jump a queue the thread:7
5 will be join before 6
7 jump a queue the thread:8
6 will be join before 7
8 jump a queue the thread:9
7 will be join before 8
8 will be join before 9
main terminate.
0 terminted.
1 terminted.
2 terminted.
3 terminted.
4 terminted.
5 terminted.
6 terminted.
7 terminted.
8 terminted.
9 terminted.

调用yield() 、sleep()、wait()、notify()等方法对锁有何影响？

面试点：

  1. 线程在执行yield()以后，持有的锁是不释放的
  2. sleep()方法被调用以后，持有的锁是不释放的
  3. 调动方法之前，必须要持有锁。调用了wait()方法以后，锁就会被释放，当wait方法返回的时候，线程会重新持有锁
  4. 调动方法之前，必须要持有锁，调用notify()方法本身不会释放锁的

sleep 示例：

public class SleepLock {
	private Object lock = new Object();
	public static void main(String[] args) {
		SleepLock sleepTest = new SleepLock();
		Thread threadA = sleepTest.new ThreadSleep();
		threadA.setName("ThreadSleep");
		Thread threadB = sleepTest.new ThreadNotSleep();
		threadB.setName("ThreadNotSleep");
		threadA.start();
		try {
			Thread.sleep(1000);
			System.out.println(" Main slept!");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		threadB.start();
	}
	private class ThreadSleep extends Thread {
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			System.out.println(threadName + " will take the lock");
			try {
				synchronized (lock) {
					System.out.println(threadName + " taking the lock");
					Thread.sleep(5000);
					System.out.println("Finish the work: " + threadName);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	private class ThreadNotSleep extends Thread {
		@Override
		public void run() {
			String threadName = Thread.currentThread().getName();
			System.out.println(threadName + " will take the lock time=" + System.currentTimeMillis());
			synchronized (lock) {
				System.out.println(threadName + " taking the lock time=" + System.currentTimeMillis());
				System.out.println("Finish the work: " + threadName);
			}
		}
	}
}

打印：

ThreadSleep will take the lock
ThreadSleep taking the lock
Main slept!
ThreadNotSleep will take the lock time=1582507400499
Finish the work: ThreadSleep
ThreadNotSleep taking the lock time=1582507404498
Finish the work: ThreadNotSleep

傅晨明
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（面经总结）一篇文章带你完整复习 Java 中线程上下文切换和多线程如何共享数据
南淮北安的博客
02-23 463
文章目录一、线程上下文切换1. 上下文切换2. 引起线程上下文切换的原因二、多线程如何共享数据1. 将数据抽象成一个类，并将对这个数据的操作封装在类的方法中2. 将Runnable对象作为一个类的内部类，将共享数据作为这个类的成员变量 一、线程上下文切换 CPU利用时间片轮询来为每个任务都服务一定的时间，然后把当前任务的状态保存下来，继续服务下一个任务。任务的状态保存及再加载就叫作线程的上下文切换 进程：指一个运行中的程序的实例。在一个进程内部可以有多个线程在同时运行，并与创建它的进程共享同一地址空间（一
Java并发编程之一：线程基础，线程之间的共享与协作
Destiny宿命的博客
10-19 429
线程基础，线程之间的共享与协作 目录 线程基础，线程之间的共享与协作 1.CPU时间片轮转机制 2.进程和线程 3.并行和并发 4.高并发编程的含义，好处及注意事项 （二）认识java的线程 1.3种创建线程的方式 2.线程安全停止工作的方式 3.线程常用方法和线程的状态 5.线程中的stop(),interrupt(),isInterrupted(),static方法int...
Java多线程资源共享
silence_Frank的博客
07-15 1162
Java多线程资源共享 我们在编写Java多线程并发控制程序时，经常需要我们考虑到多个线程之间资源共享问题。那么，什么是资源共享问题？在Java多线程中资源共享就是多个线程共用同一个变量或者对象。下面通过模拟学生进教室线程阐述两种资源共享的方法。 1. 继承Thread类 每new一个Thread类或者子类对象时，非静态属性（实例属性）都会在内存中重新加载，起不到共用资源的效果，因此我们需要将共用的对象或者变量用static修饰，使其成为类属性，在内存中只加载一次。具体代码和结果如下： Classroom类
Java线程间的共享和协作
Lbsssss的博客
09-07 648
Java线程间的共享和协作
java多线程学习三（线程间的共享和协作）
小小时光
04-18 401
目录 ● yield（）和join（）方法简介 ● 线程间的共享 ● 线程间的协作 yield（）和join（）方法简介 yield()方法：使当前线程让出CPU占有权（线程让步），但让出的时间是不可设定的。也不会释放锁资源，所有执行yield（）的线程有可能在进入到可执行状态后马上又被执行。...
JAVA 并发编程-多个线程之间共享数据（六）
热门推荐
何静媛
07-25 4万+
多线程共享数据的方式： 1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。2，如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，例如，设计4个线程。，其中两个线程每次对j增加1，另外两个线程对j每次减1，银行存取款 有两种方法来解决此类问题：将共享数据封装成另外一个对象，然后将这个对象逐一传递
Java线程的并发及并行
JSDHBIV的博客
07-19 902
并发与并行并发与并行的区别并发概念临界资源和临界区什么是线程安全？并发的特性原子性可见性有序性 并发与并行的区别 并发是指多个线程操作同一个资源，不是同时执行，而是交替执行。单核CPU，只不过因为CPU的时间片很短，速度太快，看起来是同时执行。 并行才是真正的同时执行，多核CPU。每个线程使用一个单独的CPU的资源来运行。 并发示意图： 并行示意图： 但在多数情况下，我们的即使有多核，也同样存在并行的情况，且存在并行与并发同时存在的情况。 并发概念 Java并发的重要性毋庸置疑，可以最大化的提高计算资源
笔记-1、线程基础、线程之间的共享和协作2
08-08
对于线程间共享和协作，Java提供了多种机制。`synchronized`关键字用于实现内置锁，保证同一时间只有一个线程访问共享资源，防止数据不一致。类锁锁定的是类的Class对象，而对象锁锁定的是实例对象。`volatile`...
Java多线程和并发知识整理
05-18
Java线程有新建、可运行、运行、阻塞、等待、超时等待和终止等状态。 2.2 使用方式 可以通过`Thread`类或`Runnable`接口创建线程，使用start()方法启动。 2.3 基础机制 包括线程调度、上下文切换等。 2.4 中断 线程...
Java中线程同步和线程协作学习笔记
最新发布
05-27
在Java编程中，线程同步和线程协作是多线程编程的重要概念，确保了在并发环境下程序的正确性和数据的一致性。线程同步的主要目标是解决线程安全问题，即在多线程访问共享资源时避免数据的混乱，保证程序的可再现性。...
Java多线程机制和线程之间的协作
06-10
程序是一段静态的代码，它是应用软件执行的蓝本。 进程是程序的一次动态执行过程，它对应了程序从加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。 线程是比进程更小的执行单位,一个进程在其执行过程中，可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。
多个线程之间共享数据的方式
04-19
NULL 博文链接：https://903497571.iteye.com/blog/1869428
Java基础之多线程
08-26
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提升...在实际开发中，根据需求选择合适的线程控制策略，合理使用线程池，以及妥善处理线程间的协作和通信，可以极大地提高程序的并发性能和稳定性。
深入理解java线程通信
08-25
Java 线程通信是 Java 编程中一个非常重要的概念，它可以使得多个线程之间能够相互通信和协作，从而实现更加复杂的任务。下面我们将深入理解 Java 线程通信的机制和实现方式。 一、等待通知机制 等待通知机制是 ...
并发编程（一）：线程基础、线程之间的共享与协作
nelson的博客
08-26 3106
一、基础概念 1.1 CPU核心数、线程数 **两者的关系：**cpu的核心数与线程数是1:1的关系，例如一个8核的cpu，支持8个线程同时运行。但在intel引入超线程技术以后，cpu与线程数的关系就变成了1:2。此外在开发过程中并没感觉到线程的限制，那是因为cpu时间片轮转机制（RR调度）的算法的作用。什么是cpu时间片轮转机制看下面1.2. 1.2 CPU时间片轮转机制 **含义...
Java多线程（一）--之线程范围内共享变量的概念与作用
huohua0612的专栏
03-21 2088
最近在学习多线程，通过看了一些视频教程和博客后，我觉得对自己的编程学习又有了进一步的认识，在此，以这篇博客记录下学习的知识，分享给需要的朋友。 一、首先试着创建两个线程： 创建一个测试类：ThreadScopeShareVariable public class ThreadScopeShareVariable { private static int datas = 0; pub...
Java 并发编程—线程间的共享和协作(一)
六号表哥
04-12 441
线程间的共享和协作 线程间的共享 JVM 会为每一个线程独立分配虚拟机栈空间，本地方法栈空间以及程序计数器，而对于共享内存中的变量，是对每一个线程而言是共享的，因此多线程并发访问共享内存中的变量时就会出现线程安全问题。具体可以参考JVM 内存模型这篇博客。 synchronized 内置锁 在前面提到共享资源在多个线程并发访问时会出现线程安全问题，而解决线程安全问题就是要解决以下两个问题，一是要...
线程基础、线程之间的共享和协作
Hank的专栏
02-02 751
1、线程基础、线程之间的共享和协作 基础概念 什么是进程和线程 进程是程序运行资源分配的最小单位 进程是操作系统进行资源分配的最小单位,其中资源包括:CPU、内存空间、磁盘IO等,同一进程中的多条线程共享该进程中的全部系统资源,而进程和进程之间是相互独立的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。 进程是程序在计算机上的一...
Java线程基础、线程之间的共享和协作（一）
baidu_36882394的博客
05-21 303
线程基础、线程之间的共享和协作 目录线程基础、线程之间的共享和协作什么是进程和线程CPU核心数和线程数的关系CPU时间片轮转机制澄清并行和并发高并发编程的意义、好处和注意事项多线程程序需要注意的事项 什么是进程和线程 1. 进程是程序运行资源分配的最小单位 进程是操作系统进行资源分配的最小单位，其中包括：CPU，内存空间、磁盘IO等，同一进程中的多条线程共享改进程中的全部系统资源，而进程和进程之间是相互独立的。 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值