多线程基础(笔记)

多线程:如果一个进程中同时运行了多个线程用来完成不同的工作,则称之为多线程

多线程是抢占式执行策略
多线程并不是真正的并行,而是多个线程交替占用CPU资源

多线程的好处:
充分利用CPU资源
简化编程模型
带来良好的用户体验

main方法即为主线程入口
主线程产生其他子线程
主线程必须最后完成执行,因为它执行各种关闭动作

创建线程的两种方法:
1.继承Thread类:编写简单,可直接操作线程
2.实现Runnable接口:避免单继承局限性,便于共享资源

简单示例:

package thread_example;

/**
 * 继承Thread类创建线程
 * 
 * @author Administrator
 *
 */
public class MyThread extends Thread {

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("线程------" + i);
		}
	}

	public static void main(String[] args) {
		MyThread mt = new MyThread();
		mt.start();
	}
}

package thread_example;

/**
 * 实现Runnable接口创建线程
 * 
 * @author Administrator
 *
 */
public class MyThread2 implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("线程------" + i);
		}
	}
	public static void main(String[] args) {
		MyThread2 mt = new MyThread2();
		Thread thread=new Thread(mt);
		thread.start();
	}
}

线程的状态:
创建状态,阻塞状态,就绪状态,死亡状态,运行状态

Thread类常用方法:
static void sleep(long millis) 在指定毫秒内让当前线程休眠(暂停执行)
static void yield() 暂停当前正在执行的线程对象,并执行其他线程
void setPriority(int newPriority) 更改线程优先级
void join() 等待该线程终止
void interrupt() 中断线程
boolean isAlive() 测试线程是否处于活动状态

线程优先级:
1-10,1最低,10最高,默认为5

yield():礼让,只是提供一种可能,不能保证一定会实现礼让
sleep():线程执行该方法不会释放资源
interrupt() 并不能真正的中断线程,只是将线程标记为中断状态,interrupted()会导致中断状态清除

当多个线程共享同一个资源时,一个线程未完成全部操作,而这时其他线程修改了数据,就会出现数据不安全问题,

使用同步锁(synchronized)解决线程不安全问题

死锁:当两个线程都在等待对方先完成,造成程序的停滞
死锁条件:
两个或两个以上线程在活动
某个线程拿到第一个锁之后,还想拿第二个锁,造成锁的嵌套

死锁示例:

package Test_Temp;

/**
 * 死锁模拟
 * 
 * 多线程抢占同一个资源就有可能会产生死锁现象
 * 
 * sleep500ms模拟代码执行
 * 
 * @author Administrator
 *
 */
public class Synchronized_test {
	public static void main(String[] args) {
		Object lock1 = new Object();
		Object lock2 = new Object();

		Test1 test1 = new Test1(lock1, lock2);
		Test2 test2 = new Test2(lock1, lock2);

		Thread t1 = new Thread(test1);
		Thread t2 = new Thread(test2);

		t1.start();
		t2.start();

	}

}

class Test1 implements Runnable {

	Object lock1;
	Object lock2;

	public Test1(Object lock1, Object lock2) {
		super();
		this.lock1 = lock1;
		this.lock2 = lock2;
	}

	@Override
	public void run() {
		synchronized (lock1) {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (lock2) {
			}
			System.out.println("这是线程1-------");
		}
	}

}

class Test2 implements Runnable {
	Object lock1;
	Object lock2;

	public Test2(Object lock1, Object lock2) {
		super();
		this.lock1 = lock1;
		this.lock2 = lock2;
	}

	@Override
	public void run() {
		synchronized (lock2) {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (lock1) {
			}
			System.out.println("这是线程2-------");

		}
	}
}