本篇文章主要讲一些和线程，进程，的基础常识问题
1、进程和线程的基本概念
- 进程：一个程序启动（或是一个应用启动）就是一个程序，它是资源分配的基本单元，相当于是一个装很多线程的容器
- 线程：线程是CPU调度的基本单位，每个线程都会执行进程的一些代码片段
- 串行，并行，并发
- 串行：多个线程排队，一个一个的上
- 并行：多个线程一起上，这里必须是多个CPU或是大CPU多个核的情况下，才能实现并行
- 并发：区别于高并发（1w个请求同时访问这个接口）里的定义，这里的并发是指CPU在极短的时间内对不同的线程进行切换，来达到多个线程同时运行这样的效果。单核但CPU也可以并发但是不能并行。
- 同步，异步，阻塞，非阻塞
- 同步，异步：在调用一个功能时，看它是否会主动给调用者反馈信息，会主动反馈的就是异步，反之就是同步
- 阻塞，非阻塞：在调用一个功能时，此时调用者还能不能同时去干其他事情，如果可以，那就是非阻塞，反正就是阻塞
2、创建线程的方式
从本质上说，创建线程的方式只有一种，那就是创建一个线程对象，然后调用start方法。
- 从大的方面来说，创建线程的方法有三种
- 继承Tread类，重新run方法
public class MiTest { public static void main(String[] args) { MyJob t1 = new MyJob(); t1.start(); for (int i = 0; i < 100; i++) { System.out.println("main:" + i); } } } class MyJob extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("MyJob:" + i); } } }- 实现Runable接口，重写run方法
public class MiTest { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); Thread t1 = new Thread(myRunnable); t1.start(); for (int i = 0; i < 1000; i++) { System.out.println("main:" + i); } } } class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("MyRunnable:" + i); } } }它对应的还有两种常见的实现方式
1. 匿名内部类
2. lambad方式// 匿名内部类方式 Thread t1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("匿名内部类:" + i); } } });// lambad表达式的方式 Thread t2 = new Thread(() -> { for (int i = 0; i < 100; i++) { System.out.println("lambda:" + i); } });- 实现Callable接口，重写call方法
Callable它的call方法可以带结果返回，而且他是一种非阻塞的同步方法
public class MiTest { public static void main(String[] args) throws ExecutionException, InterruptedException { //1. 创建MyCallable MyCallable myCallable = new MyCallable(); //2. 创建FutureTask，传入Callable FutureTask futureTask = new FutureTask(myCallable); //3. 创建Thread线程 Thread t1 = new Thread(futureTask); //4. 启动线程 t1.start(); //5. 做一些操作 //6. 要结果 Object count = futureTask.get(); System.out.println("总和为：" + count); } } class MyCallable implements Callable{ @Override public Object call() throws Exception { int count = 0; for (int i = 0; i < 100; i++) { count += i; } return count; } }
3、线程的使用方式
3.1、线程的状态
- new：Thread对象被创建出来，但是还没有执行start方法
- runnnable：对象调用了start方法，正常运行对应的代码
- blocked：被阻塞，如在多线程加锁的情况下，对应的线程没有拿到锁，就会处于blocked状态
- waiting：调用wait方法，这种需要手动唤醒
- time_waiting：调用sleep或是join方法，到了时间或是特定的条件达成就会唤醒，继续跑
- terminated：run方法执行完之后，线程对应的状态
3.2、现成常用的方法
- 获取当前线程：Thread.currentThread()
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 获取当前线程的方法
Thread main = Thread.currentThread();
System.out.println(main);
// "Thread[" + getName() + "," + getPriority() + "," + group.getName() + "]";
// Thread[main,5,main]
}
- 线程的名称：thread.getName()
public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName());
});
t1.setName("模块-功能-计数器");
t1.start();
}
- 线程的优先级：thread.setPriority(1)
其实它就是CPU调度线程的优先级，Java中给线程设置了1~10的优先级别
public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("t1:" + i);
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("t2:" + i);
}
});
t1.setPriority(1);
t2.setPriority(10);
t2.start();
t1.start();
}
- 线程的让步：Thread.yield()
通过Thread的静态方法yield调用，让当前线程从运行状态转变为就绪状态
public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
if(i == 50){
Thread.yield();
}
System.out.println("t1:" + i);
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println("t2:" + i);
}
});
t2.start();
t1.start();
}
- 线程的休眠：Thread.sleep()
让线程从运行状态变为等待状态，sleep方法会抛出一个InterruptedException
public static void main(String[] args) throws InterruptedException {
System.out.println(System.currentTimeMillis());
Thread.sleep(1000);
System.out.println(System.currentTimeMillis());
}
- 线程的强占：thread.join()
假如在t1中运行t2.jooin()，t1会进入等待状态，一直等到t2运行完毕之后，t1才会进入就绪状态等待CPU运行，如果是t2.join(2000)，t1会等t2运行2s之后再开始运行，如果在这2s之内，t2先运行完了，t1也会提前开始运行
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("t1:" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println("main:" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (i == 1){
try {
t1.join(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
- 守护线程
- 现成的等待和唤醒
- wait, notify() , notifyAll()
public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { sync(); },"t1"); Thread t2 = new Thread(() -> { sync(); },"t2"); t1.start(); t2.start(); Thread.sleep(12000); synchronized (MiTest.class) { MiTest.class.notifyAll(); } } public static synchronized void sync() { try { for (int i = 0; i < 10; i++) { if(i == 5) { MiTest.class.wait(); } Thread.sleep(1000); System.out.println(Thread.currentThread().getName()); } } catch (InterruptedException e) { e.printStackTrace(); } }
3.3、线程的结束方式
让线程停止的方法很多，比如：调用stop()，通过共享变量来破坏死循环来让线程运行结束停止掉，通过interrupt()
其中通过interrupt()，通过打断线程的方式结束时最常见的，也是比较优雅的一种方式
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while(true){
// 获取任务
// 拿到任务，执行任务
// 没有任务了，让线程休眠
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("基于打断形式结束当前线程");
return;
}
}
});
t1.start();
Thread.sleep(500);
//把t1停止掉，此时会进行
t1.interrupt();
}
3.3、wait和sleep的区别
- sleep属于Thread类的Static方法，wait是Object类的方法
- sleep属于Timed_waiting，它根据设置自动唤醒，wait属于Waiting，需要手动唤醒
- sleep方法在持有锁时，是不会释放锁资源的，wait在执行之后，会释放锁资源
- sleep方法在有无锁的情况下都可以执行，但是wait方法只有在有锁的时候运行
- wait方法会将持有锁的线程从owner扔到waitSet中，这个操作是在修改ObjectMonitor对象，如果没有持有synchronized锁的话，是无法操作ObjectMonitor独享的
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
