JAVA多线程

JAVA多线程

1. Thread类

• 实现步骤
• MyThread类文件，继承Thread类
• 重写类中的run方法
• 在测试文件中新建MyThread类对象mt
• mt调用start()方法

1.1 设置和获取线程名称

• void setName(String name) 将此线程的名称更改为等于参数name
• String getName() 返回此线程的名称
• Thread currentThread() 返回对当前正在执行的线程对象的引用

public class MyThread extends Thread {
	public MyThread() {}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		//void setName(String name)：将此线程的名称更改为等于参数 name
		my1.setName("高铁");
		my2.setName("飞机");
		//Thread(String name)
		MyThread my1 = new MyThread("高铁");
		MyThread my2 = new MyThread("飞机")
		my1.start();
		my2.start();
		//static Thread currentThread() 返回对当前正在执行的线程对象的引用
		System.out.println(Thread.currentThread().getName());
	}
}

1.2 线程优先级

线程调度

• 两种调度方式
  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一 个，优先级高的线程获取的 CPU 时间片相对多一些
• Java使用的是抢占式调度模型
• 随机性
  • 假如计算机只有一个 CPU，那么 CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一 定的

优先级相关方法

• final int getPriority() 返回此线程的优先级
• final void setPriority(int newPriority) 更改此线程的优先级 线程默认优先级是5；线程优先级的范围
  是：1-10

1.3 线程控制

• static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数
• void join() 等待这个线程死亡
• void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

2.实现Runnable接口

实现步骤

• 定义MyRunnable类，实现Runnable接口
• 在MyRunnable类中重写run()方法
• 测试文件中新建MyRunnable类对象mr
• 新建Thread对象,并把mr作为构造方法的参数
• 启动线程

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		for(int i=0; i<100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}
public class MyRunnableDemo {
	public static void main(String[] args) {
		//创建MyRunnable类的对象
		MyRunnable my = new MyRunnable();
		//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
		//Thread(Runnable target)
		// Thread t1 = new Thread(my);
		// Thread t2 = new Thread(my);
		//Thread(Runnable target, String name)
		Thread t1 = new Thread(my,"高铁");
		Thread t2 = new Thread(my,"飞机");
		//启动线程
		t1.start();
		t2.start();
	}
}

2.1 同步代码块解决数据安全问题

同步代码块格式,run()方法中添加

synchronized(任意对象) {
	多条语句操作共享数据的代码
}

同步的好处和弊端

• 好处：解决了多线程的数据安全问题
• 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

2.2 同步方法解决数据安全问题

• 同步方法的格式:就是把synchronized关键字加到方法上,同步方法的锁对象是this

修饰符 synchronized 返回值类型 方法名(方法参数) {
	方法体；
}

• 静态同步方法:就是把synchronized关键字加到静态方法上,同步静态方法的锁对象是class

修饰符 static synchronized 返回值类型 方法名(方法参数) {
	方法体；
}

• 代码演示

public class SellTicket implements Runnable {
	private static int tickets = 100;
	private int x = 0;
	@Override
	public void run() {
		while (true) {
			sellTicket()；
		}
	}
	// 同步方法
	// private synchronized void sellTicket() {
		// if (tickets > 0) {
			// try {
				// Thread.sleep(100);
			// } catch (InterruptedException e) {
				// e.printStackTrace();
			// }
			// System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
			// tickets--;
		// }
	// }
	// 静态同步方法
	private static synchronized void sellTicket() {
		if (tickets > 0) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
			tickets--;
		}
	}
}
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}

2.3 线程安全的类

• StringBuffer
  • 线程安全，可变的字符序列
  • 从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操
    作，但它更快，因为它不执行同步
• Vector
  • 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集
    合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector
• Hashtable
  • 该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值
  • 从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替
    Hashtable

2.3 Lock锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

• ReentrantLock() 创建一个ReentrantLock的实例

加锁解锁方法

• void lock() 获得锁
• void unlock() 释放锁

public class SellTicket implements Runnable {
	private int tickets = 100;
	private Lock lock = new ReentrantLock();
	@Override
	public void run() {
		while (true) {
			try {
				lock.lock();
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "正在出售
					第" + tickets + "张票");
					tickets--;
				}
			} finally {
				lock.unlock();
			}
		}
	}
}
public class SellTicketDemo {
	public static void main(String[] args) {
		SellTicket st = new SellTicket();
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");
		t1.start();
		t2.start();
		t3.start();
}
}

3. 生产者消费者模式

• void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
• void notify() 唤醒正在等待对象监视器的单个线程
• void notifyAll() 唤醒正在等待对象监视器的所有线程