RandomAccessFile类

RandomAccessFile readFile = new RandomAccessFile(srcFile, "r")创建一个只读对象

第二个参数mode可以为r、rw、rws、rwd

seek(long len)偏移量

可随机读取文件内容

多线程

1.线程与进程的定义

1.进程

进程：运行的程序，进程是内存分配的最小单位，进程内可通过变量共享数据

多进程的原因：解决同时并行多个任务

多个进程之间传递数据：文件、数据库、网络、PipedStream（管道流）

2.线程

线程：进程中的程序执行序列

单线程程序：进程中只有一个线程的程序为

多线程程序：进程中包含多个线程（多个执行序列）

多线程意义：

1.解决同时并行多个任务

2.进程的创建，销毁开销较大

多线程的优点及应用场景：

1.可以让程序并行操作，减少程序执行时间

2.多线程同时复制大文件

3.启动页面时需加载大量的数据，通过建立新线程在后台执行，提高用户使用舒适性

4.创建后台线程，自己计时执行周期性的任务

5.多个线程同时扫描磁盘文件

进程中必须有一个或多个线程，当所有的线程执行完毕，进程就执行完成

多个线程是在同一块内存空间的，可以通过变量共享数据

线程是CPU执行的最小单元

3.线程调度的两个方式

1.抢占式

2.轮转式

线程的状态

​

4.进程与线程的区别

1.都是任务调度的单位

2.进程中必须有一个或多个线程，每个线程包含在进程中

3.进程是内存分配的最小单位，同一进程的所有线程共享内存，线程是CPU执行的最小单位，操作系统依据线程分配执行的时间片

4.线程轻便，创建，销毁调度的开销比进程小

5.线程创建和启动的方式

1.继承Thread类

public class ThreadTest {
	// 创建一个继承Thread的类
	static class MyThread extends Thread {
		// 重写run()方法
		@Override
		public void run() {
			for (int i = 0; i < 1000; i++) {
				// currentThread()获取当前线程
				// getName()获取线程名
				System.out.println(Thread.currentThread().getName() + ":" + i);
				if (Thread.currentThread().isInterrupted()) {
					System.out.println(Thread.currentThread().getName() + ":中断");
					return;
				}
			}
			while (true) {	
				System.out.println("我在执行");
			}
		}
	}

	public static void main(String[] args) {
//		testThreadJoin();
//		testInterrupt();
		testDaemon();
	}

	private static void testDaemon() {
		// 创建子线程类对象
		MyThread myThread = new MyThread();
		// 设置子线程名字
		myThread.setName("子线程");
		// 设置为守护线程
		myThread.setDaemon(true);
		// 启动子线程
		myThread.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("主线程:" + i);
		}
	}

	private static void testInterrupt() {
		// 创建子线程类对象
		MyThread myThread = new MyThread();
		// 设置子线程名字
		myThread.setName("子线程");
		// 启动子线程
		myThread.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("主线程:" + i);
			if (i == 500) {
				myThread.interrupt();
			}
		}
	}

	private static void testThreadJoin() {
		// 创建子线程类对象
		MyThread myThread = new MyThread();
		// 设置子线程名字
		myThread.setName("子线程");
		// 启动子线程
		myThread.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("主线程:" + i);
			// join()合并线程
			try {
				if (i == 500) {
					myThread.join();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

2.实现Runable接口（最常用）

public class TestRunable {
	public static void main(String[] args) {
//		lumbdaRunableTest();
		RunableTest();
	}

	private static void RunableTest() {
		// 使用匿名内部类创建一个Runable对象
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 1000; i++) {
					System.out.println("子线程：" + i);
				}
			}
		});
		thread.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("主线程：" + i);
		}
	}

	public static void lumbdaRunableTest() {
		// 使用lambda表达式创建一个Runable对象
		Thread thread = new Thread(() -> {
			for (int i = 0; i < 1000; i++) {
				System.out.println("子线程：" + i);
			}
		});
		thread.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("主线程：" + i);
		}
	}
}

3.实现Callable接口

Java的JUC包

java.util.concurrent（Java并行开发包）

public class CallableTest {
	public static void main(String[] args) {
		callableTest();
	}
	// 创建callable对象
	private static void callableTest() {
		Callable<Integer> callable = new Callable<Integer>() {
			
			@Override
			public Integer call() throws Exception {
				for (int i = 0; i < 1000; i++) {
					System.out.println("子线程：" + i);
				}
				return 9999999;
			}
		};
		// 创建中间对象futureTask将callable对象转为Thread对象
		FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
		// 使用FutureTask对象创建Thread对象
		Thread thread = new Thread(futureTask);
		// 设置优先级为最高
		thread.setPriority(Thread.MAX_PRIORITY);
		thread.start();
		for (int i = 0; i < 1000; i++) {
			System.out.println("主线程：" + i);
		}
		try {
			// futureTask.get()获取callable对象执行完的返回值
			System.out.println(futureTask.get());
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}
}

4.来自线程池

5.Runable与Callable的区别

1.都能实现线程

2.返回类型不同：Callable有返回类型，Runable没有返回类型

3.启动方式不同

Runable：使用它的对象创建线程对象，使用线程对象的start()方法启动

Callable：使用它的对象创建FutureTask对象，再使用FutyreTask的对象创建线程对象，再使用线程对象的start()方法启动

6.线程的常用方法

1.currentThread()获取当前线程

2.getName()获取线程名

3.setName("子线程")设置线程名字

4.setDaemon(true)设置为守护线程或用户线程.

5.myThread.start()启动线程

6.thread.setPriority(Thread.MAX_PRIORITY)设置优先级为最高

优先级为1-10

最高优先级Thread.MAX_PRIORITY为10

自然优先级Thread.NORM_PRIORITY为5

最低优先级Thread.MIN_PRIORITY为1

7.myThread.isInterrupted()判断线程是否中断

8.interrupt()设置线程中断

9.join()合并线程（多线程变单线程）

10.yield()线程暂停执行进入就绪态

守护线程（后台线程）优先级低，主线程停止，守护线也停止

守护线程会在所有的用户线程结束，自动结束运行

GC(垃圾回收器)就是一个最著名的守护线程

Java定时器

Timer与TimerTask

Timer timer = new Timer()创建Timer对象

TimerTask task = new TimerTask() { @Override public void run() { System.out.println(format.format(new Date())); } };

创建TimerTask对象

	private static void timerTaskTest() {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		TimerTask task = new TimerTask() {
			@Override
			public void run() {
				System.out.println(format.format(new Date()));
			}
		};
		Timer timer = new Timer();
		// 一秒执行一次，从第0秒开始
		timer.schedule(task,0,1000);
	}