目录
进程和线程
并发和并行
如何创建一个线程？
1，继承Thread类
2，实现Runnable接口
3. Callable<>接口
线程Thread类的一些重要方法
守护线程：
时间长了，并发编程的基础知识总忘，来记录一下：
进程和线程
进程：资源分配的最小单元，什么是资源？CPU，内存，网卡等等
线程：进程中的一个实体，不能单独存在，依赖进程存在。CPU调度的最小单元。
并发和并行
并发：单位时间内，多个任务交替执行。
并行：同一时刻，每个任务同时执行。多核CPU可以实现并行。
如何创建一个线程？
1，继承Thread类
package cn.tulingxueyuan.xiaoshanshan.base;
public class UseThread {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
}
}
class MyThread extends Thread{
@Override
public void run() {
//要执行的代码
System.out.println("hello ,Thread");
}
}2，实现Runnable接口
package cn.tulingxueyuan.xiaoshanshan.base;
public class UseRunnable {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable); // Runnable接口也要借助Thread类才能启动
thread.start();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
// 要执行的代码
System.out.println("hello ,Runnable");
}
}
其实Thread类也实现了Runnable接口
我们在启动一个java进程的时候，main（）是主线程，在main（）方法中又启动了子线程，当主线程运行结束了不意味着进程就结束了，所有线程结束了进程才结束。在main线程中启动一个子线程Thread-0，主线程不会因为有子线程的执行而阻塞，main线程和线程Thread-0会并行执行。也就是说子线程和主线程之前是异步执行的。
如下图程序中，当运行该程序的时候，控制台（Terminal中）输入jconsole，可以查看线程的情况，当main()方法执行完成之后会退出，Thread-0会继续执行。当Thread-0执行结束以后，会卡死或者断开。
package cn.tulingxueyuan.xiaoshanshan.base;
public class CatThreadDemo {
public static void main(String[] args) {
Cat cat = new Cat();
cat.start();
for(int i =0 ;i<60;i++){
System.out.println(i +"， 执行线程名"+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Cat extends Thread{
int times = 0;
@Override
public void run() {
String name = Thread.currentThread().getName();
while(true){
System.out.println("喵喵，我是一只小猫猫~" + (++times) + "线程名称：" + name);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times == 80){
break ;
}
}
}
} 
3. Callable<>接口
（面试的时候如果问启动线程有几种方法，这种方式其实不能算是创建线程的方法，但是可以作为补充，详细看后面的内容）
Thread类的run方法和Runnable接口的run方法都是返回的空值，那么想得到一个线程的运行结果怎么办呢?
用Callable接口。
那这个结果怎么拿到呢？阻塞吗？那么线程异步又有什么用呢？为了解决这个问题。JDK又为我们提供了一个类——Future<>接口(优势JUC包中的类，看看JUC多么重要)
但是Future是个接口，我们主要用这个接口的get()方法，怎么用呢？我们每用一次就去实现一次吗？
不是的，JUC又为我们提供了一个FutureTask类
Callable怎么传给Thread呢？没有这种方法啊！怎么办呢？将Callable包装成一个FutureTask执行
FutureTask由于是Runnable的子类，可以交给Thread类启动了。
package cn.tulingxueyuan.xiaoshanshan.base;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable());
new Thread(futureTask).start();
System.out.println(futureTask.get()); // get阻塞了
System.out.println("主线程结束");
}
static class MyCallable implements Callable<Integer>{
private int count ;
@Override
public Integer call() throws Exception {
Thread.sleep(1000);
for(int i = 0;i<100;i++){
count ++ ;
}
System.out.println(Thread.currentThread().getName() + "线程结束,结果是："+count);
return count;
}
}
}
这里就有一个面试题：新启动一个线程有几种方式？答案：官方给出的是：两种。
根据Thread类写在源码上的注释，其实就两种:一种是继承Thread类，另外一种是实现Runnable接口。
线程Thread类的一些重要方法
start()方法：一个线程只有调用这个方法后，才能真正和操作系统的线程挂钩，
底层是调用了start0()方法，这个方法是native方法，即本地方法，底层是C或者C++实现的，是JVM来调用的，真正实现了多线程。
run()方法：这个方法中是要写的代码逻辑
setName()设置线程名称
getName()得到线程名称
sleep()睡眠，不会释放锁 Thread类调用的静态方法
interrupt()中断方法，不是终止方法
yiled()静态方法，礼让方法，不一定礼让成功，在Cpu资源比较紧张的时候，礼让的效果比较明显
join()线程的插队（这里有个面试题：有三个线程：t1,t2,t3,如何保证t3在t2之前完成，t2在t1之前完成）
package cn.tulingxueyuan.xiaoshanshan.base;
public class UseJoin {
public static void main(String[] args) {
JoinThread t1 = new JoinThread();
JoinThread t2 = new JoinThread();
JoinThread t3 = new JoinThread();
t1.setName("t1");
t2.setName("t2");
t3.setName("t3");
t1.setT(t2);
t2.setT(t3);
t1.start();
t2.start();
t3.start();
}
}
class JoinThread extends Thread{
Thread t ;
public void setT(Thread t) {
this.t = t;
}
@Override
public void run() {
if(null!=t){
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println( "线程：" + Thread.currentThread().getName() + "执行我的逻辑...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
执行结果：
守护线程：
守护线程服务于用户线程，当用户线程结束的时候，守护线程也结束了
package cn.tulingxueyuan.xiaoshanshan.base;
public class DaemonThread {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for (int i =0;i<10;i++){
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "打印出：" +i);
}
}
}
class MyDaemonThread extends Thread{
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "打印出：" + Math.random()*100+1);
}
}
}
文章来源：https://www.toymoban.com/news/detail-480506.html
看，main线程结束了，守护线程Thread-0也结束了。文章来源地址https://www.toymoban.com/news/detail-480506.html
到了这里，关于复习并发编程的基础知识（一）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
