线程知识点

NicenJack

已于 2022-11-14 15:28:15 修改

阅读量1.9k

点赞数 1

分类专栏： JAVA开发重点知识梳理文章标签：线程线程调度策略死锁线程同步线程协作

于 2019-03-26 14:28:47 首次发布

本文链接：https://blog.csdn.net/NicenJack/article/details/88814048

版权

JAVA开发重点知识梳理专栏收录该内容

5 篇文章 0 订阅

订阅专栏

线程知识点

进程：运行中的程序，有自己的地址和空间，基于进程的计算机能运行多个程序，即多进程

线程：进程中的一个执行流程，一个进程可以运行多个线程，即多线程

主线程：JAVA本身就是基于线程的，一个JAVA程序至少包含一个主线程，启动JAVA程序，主线程立即运行。（main方法所在线程即为主线程，主线程是产生其他线程的线程）

线程创建一（继承thread类，重写run方法，创建对象，调用start方法执行）

package test.th;

class Test extends Thread{
	@Override
	public void run() {
		System.out.println("ThreadTest线程");
	}
}

public class ThreadTest{
	public static void main(String[] args) {
		Thread t = new Test();
		t.start();
		
	}
}

线程创建二（实现runnable接口，实现run方法，创建对象，执行start方法）

package test.th;

class Test implements Runnable {

	@Override
	public void run() {
		System.out.println("Test线程");
	}

}

public class ThreadTest {
	public static void main(String[] args) {
		Thread t = new Thread(new Test());
		t.start();
	}
}

线程的状态

新建（NEW）：对象被创建，其start方法未被调用
就绪（RUNNABLE）: 线程对象的start方法被调用，线程等待CPU的使用权
允许（RUNNING）：线程占用CPU，执行线程中代码
阻塞（BLOCKED/WAITING）：线程对象放弃CPU，暂时停止运行，不再竞争CPU
死亡（dterminated）：线程对象的run方法执行完成（stop方法被调用）

（注意）处于阻塞状态下线程对象不会竞争和占用CPU，结束阻塞状态会进入就绪状态

线程调度：合理分配多个线程对CPU资源占用

线程调度策略：任何线程都有占用CPU的机会，防止线程长期占用CPU，控制线程放弃CPU

Thread.sleep方法，使当前线程休眠（从运行状态进入阻塞状态，休眠结束进入就绪状态）
调用其他线程的join方法，是当前线程等待其他线程运行完毕（当前线程进入阻塞状态，结束等待后进入就绪状态）
由于等待 I/O 事件被阻塞（结束阻塞后进入就绪状态）
对象.wait方法，是当前线程等待（需与同步机制配合使用）（结束等待后进入就绪状态）
Thread.yield方法，使当前线程让出CPU控制权（让步）（从运行状态进入就绪状态）

线程同步：访问共享资源时多个线程相互间的协调和控制

线程同步目的：实现多线程对共享资源有序可控的访问，保障共享资源数据安全，避免死锁

（注意）：并行程序设计中，共享资源越多程序设计将越复杂，应尽量减少共享资源的使用

线程的互斥同步：使用synchronized加锁的方式实现（确保同时只有一个线程执行特定的代码块，实现该代码块的原子性）

1 同步代码块（当前锁对象为：obj对象）

package test.th;

class 测试同步代码{
	static Object obj = new Object();
	public static void tt() {
		synchronized (obj) {
			System.out.println("测试同步代码块"+obj);
		}
	}
}

class 同步代码 extends Thread {
	
	@Override
	public void run() {
		测试同步方法.tt();
	}
}

public class 同步代码块 {
	
	public static void main(String[] args) {
		Thread t = new 同步代码();
		t.start();
	}
}

2 同步实例方法（当前锁对象为：this）

package test.th;

class 测试同步方法 {
	public synchronized void tt() {
		System.out.println("测试同步方法");
	}
}

class 同步方法 implements Runnable {

	@Override
	public void run() {
		new 测试同步方法().tt();
	}

}

public class 同步实例方法 {
	public static void main(String[] args) {
		Thread t = new Thread(new 同步方法());
		t.start();
	}
}

3 同步静态方法(当前锁对象为：所在类)

与同步方法类似，将synchronized添加到静态方法上

线程协作：多线程互斥同步基础上，使线程按照条件，有目的，有计划的交互协同进行

线程协作机制：wait-notify通过wait,notify,notifyAll方法实现(通过锁对象调用)

wait：线程退出监视器进入等待状态，直到其他线程进入相同的监视器并调用notify
notify：唤醒一个等待（当前线程所持有的）监视器的线程
notifyAll：唤醒所有等待（当前线程所持有的）监视器的线程

死锁：当两个线程循环依赖两个同步对象锁（一个线程需求对象锁1并释放对象锁2，而另一线程同时需求对象锁2并释放对象锁1）

package test.th;
class 测试类{
	private static Object obj1 = new Object();
	private static Object obj2 = new Object(); 
	public static void test1() {
		synchronized (obj1) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (obj2) {
				System.out.println("test1==执行1");
			}
		}
	}
	public static void test2() {
		synchronized (obj2) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (obj1) {
				System.out.println("test2==执行2");
			}
		}
	}
}
public class 死锁 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				测试类.test1();
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				测试类.test2();
			}
		});
		t1.start();
		t2.start();
	}
}