本文章为 javaEE初阶 教学
1、计算机是如何工作的
2、什么是操作系统
3、什么是进程
4、操作系统如何管理进程
5、什么是PCB
6、PCB中的一些属性
7、什么是线程
8、线程和进程的区别
9、java中的Thread类用法
1、了解什么是API
2、关于操作系统
3、进程(跑起来的程序)
4、操作系统如何管理进程
5、PCB中的一些属性
6、进程的调度与隔离性
7、线程
8、经典面试题(线程和进程的区别)
9、Java中的 Thread 类
10、线程的状态
11、线程安全
12、什么是可重入
13、标准库
14、针对于内存可见性的另外一种解释
15、缓存
16、volatile 和 synchronized区别(仅针对于java)
17、wait 和 notify
18、线程安全的单例模型
19、阻塞队列实现—生产者消费者模型
20、定时器的模拟实现
21、线程池的模拟实现
class MyThread extends Thread{
@Override
public void run() {
System.out.println("这是一个线程");
}
}
public class Test {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
}
}
class MyRunable implements Runnable{
@Override
public void run() {
System.out.println("这是一个线程");
}
}
public class Test {
public static void main(String[] args) {
Thread t = new Thread(new MyRunable());
t.start();
}
}
public class Test {
public static void main(String[] args) {
Thread t = new Thread(){
@Override
public void run() {
System.out.println("这是一个线程");
}
};
t.start();
}
}
public class Test {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("这是一个线程");
}
});
t.start();
}
}
public class Test {
public static void main(String[] args) {
Thread t = new Thread(()-> System.out.println("这是一个线程"));
t.start();
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(5000);
t.interrupt();
}
}
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
});
t.start();
Thread.sleep(5000);
t.interrupt();
}
}
/**
* Created with IntelliJ IDEA.
* Description:
* User: Lenovo
* Date: 2022-03-31
* Time: 9:29
*/
//线程安全的单例模型
//1、饿汉模型
class Singleton{
private static Singleton instance = new Singleton();
private Singleton(){};
public static Singleton getInstance() {
return instance;
}
}
public class Demo {
public static void main(String[] args) {
Singleton instane = Singleton.getInstance();
}
}
/**
* Created with IntelliJ IDEA.
* Description:
* User: Lenovo
* Date: 2022-03-31
* Time: 9:31
*/
//线程安全的单例模型 懒汉模型
class Singleton2{
private volatile static Singleton2 instance = null;
private Singleton2(){};
public static Singleton2 getInstance() {
if(instance == null){
synchronized (Singleton2.class){
if(instance == null){
instance = new Singleton2();
}
}
}
return instance;
}
}
public class Demo2 {
public static void main(String[] args) {
Singleton2 instance = Singleton2.getInstance();
}
}
/**
* Created with IntelliJ IDEA.
* Description:
* User: Lenovo
* Date: 2022-03-31
* Time: 9:34
*/
//通过阻塞队列实现生产者消费者模型
class MyBlockingQueue{
private int[] data = new int[1000];
private int head = 0;
private int tail = 0;
private int size = 0;
private Object locker = new Object();
public void put(int val) throws InterruptedException {
synchronized (locker){
if(size == data.length){
locker.wait();
}
data[tail] = val;
tail++;
if(tail >= data.length){
tail = 0;
}
size++;
locker.notify();
}
}
public Integer take() throws InterruptedException {
synchronized (locker){
if(size == 0){
locker.wait();
}
int ret = data[head];
head++;
if(head >= data.length){
head = 0;
}
size--;
locker.notify();
return ret;
}
}
}
public class Demo3 {
public static void main(String[] args) {
MyBlockingQueue qu = new MyBlockingQueue();
Thread produce = new Thread(()->{
int num = 0;
while(true){
System.out.println("生产了:"+num);
try {
qu.put(num);
num++;
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
produce.start();
Thread consumer = new Thread(()->{
while(true){
try {
int num = qu.take();
System.out.println("消费了:"+num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
consumer.start();
}
}
import java.util.Comparator;
import java.util.concurrent.PriorityBlockingQueue;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Lenovo
* Date: 2022-03-31
* Time: 10:09
*/
//先描述一个任务
class MyTask{
//任务具体是什么
private Runnable runnable;
//任务完成的具体时间
private long time;
//给任务初始化
public MyTask(Runnable runnable,long delay){
this.runnable = runnable;
this.time = System.currentTimeMillis() + delay;
}
//执行任务
public void run(){
runnable.run();
}
public long getTime() {
return time;
}
}
//组织这些任务
class MyTimer {
//使用带有优先级的阻塞队列
PriorityBlockingQueue<MyTask> qu = new PriorityBlockingQueue<>(10, new Comparator<MyTask>() {
@Override
public int compare(MyTask o1, MyTask o2) {
return (int) (o1.getTime() - o2.getTime());
}
});
//把任务放到阻塞队列中
public void schedule(Runnable runnable, long delay) {
MyTask myTask = new MyTask(runnable, delay);
//这里成功放一个元素就通知一下
qu.put(myTask);
synchronized (locker) {
locker.notify();
}
}
private Object locker = new Object();
//创建一个扫描贤臣去寻找先执行的任务
public MyTimer(){
Thread t = new Thread(() -> {
while (true) {
try {
MyTask myTask = qu.take();
long curTime = System.currentTimeMillis();
//这里会造成忙等
if (curTime < myTask.getTime()) {
qu.put(myTask);
//等待差值的时间
synchronized (locker) {
locker.wait(myTask.getTime() - curTime);
}
} else {
myTask.run();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
public class Demo4 {
public static void main(String[] args) {
MyTimer myTime = new MyTimer();
myTime.schedule(new Runnable() {
@Override
public void run() {
System.out.println("hello timer");
}
},3000);
System.out.println("main");
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Lenovo
* Date: 2022-03-31
* Time: 10:18
*/
//模拟实现线程池
class MyThreadPool{
//创建任务并使用阻塞队列组织任务
private BlockingQueue<Runnable> qu = new LinkedBlockingQueue<>();
//创建一个工作类线程
static class Worker extends Thread{
private BlockingQueue<Runnable> qu = null;
public Worker(BlockingQueue<Runnable> qu){
this.qu = qu;
}
public void run(){
while(true){
//从阻塞队列中取出来一个任务执行
try {
Runnable runnable = qu.take();
runnable.run();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//把执行好的线程组织在顺序表中
List<Thread> workers = new ArrayList<>();
public MyThreadPool(int n){
for (int i = 0; i < n; i++) {
Worker worker = new Worker(qu);
worker.start();
workers.add(worker);
}
}
//把任务提交到阻塞队列中
public void submit(Runnable runnable) throws InterruptedException {
qu.put(runnable);
}
}
public class Demo5 {
public static void main(String[] args) throws InterruptedException {
MyThreadPool pool = new MyThreadPool(10);
for (int i = 0; i < 100; i++) {
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello pool");
}
});
}
}
}