[游戏开发]多线程的使用

前言

多线程：同一时刻办多件事情
多线程的使用——使用Thread类进行操作

创建线程的几种方式

1. 继承Thread类，然后重写run方法

2. 实现Runnable接口，重写run方法

3. 重写Callable接口，重写call方法。这种方式可以查看返回值和引发异常。通过Futruetask获取返回值

   • 创建一个实现 callable 接口的类，重写 call 方法
   • 创建一个FutureTask 对象接收实现的callable接口的类
   • 创建 Thread 类，放入 FutureTask 的实现类，然后调用Start 方法，这样就会调用call 方法
   • 使用 FutureTask 对象的get 方法获取 call 的返回值。注意get方法会阻塞线程，一般需要异步或者放在最后使用。

4. 使用线程池

   • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
   • Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
   • Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
   • Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
   • Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

线程中的常用方法

• void start(): 启动线程，并执行对象的run()方法
• run(): 线程在被调度时执行的操作
• String getName(): 返回线程的名称
• void setName(String name):设置该线程名称
• static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
• static void yield()：线程让步
• 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
• 若队列中没有同优先级的线程，忽略此方法
• join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
• 低优先级的线程也可以获得执行
• static void sleep(long millis)：(指定时间:毫秒) ?令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
• 抛出InterruptedException异常
• stop(): 强制线程生命期结束，不推荐使用
• boolean isAlive()：返回boolean，判断线程是否还活着

线程的调度

1. 时间片（同优先级线程组成先进先出队列（先到先服务），使用时间片策略）
2. 抢占式（对高优先级，使用优先调度的抢占式策略）

线程的优先等级

• MAX_PRIORITY：10
• MIN _PRIORITY：1
• NORM_PRIORITY：5

涉及的方法

getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级

说明

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
PS:Java中的线程分为两类,一种是守护线程，一种是用户线程。

线程使用的代码示例

Thread/Runnable/Callable的使用

/*创建多线程的方式：
1.继承Thread
2.实现Runnable
3.实现Callable

*/
class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println("-----MyThread01");
    }
}

class MyThread02 implements Runnable {
    public void run() {
        System.out.println("-----MyThread02");
    }
}

class MyThread03 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("-----MyThread03");
        return 200;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        new MyThread01().start();
        new Thread(new MyThread02()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread03());
        new Thread(futureTask).start();
        try {
            Integer value = futureTask.get();
            System.out.println(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程池的使用

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//创建并使用多线程的第四种方法：使用线程池
class MyThread implements Runnable {

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

}

public class ThreadPool {
	public static void main(String[] args) {
		// 1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
		ExecutorService pool = Executors.newFixedThreadPool(10);
		// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程
		// 并执行相关的run()
		pool.execute(new MyThread());
		pool.execute(new MyThread());
		pool.execute(new MyThread());
		// 3.结束线程的使用
		pool.shutdown();

	}
}

Lock的使用示例

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
	int ticket = 100;
	private final ReentrantLock lock = new ReentrantLock();
	public void run(){
		
		while(true){
			try{
				lock.lock();
				if(ticket > 0){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(ticket--);
				}else{
					break;
				}
			}finally{
				lock.unlock();
			}
		}
	}
}

public class ThreadLock {
	public static void main(String[] args) {
		Window t = new Window();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		
		t1.start();
		t2.start();
	}
}