概念定义：线程是进程中的一个任务，也叫顺序执行流，同时执行一个进程中的多个任务（也就是执行多个顺序执行流）就是多线程
程序：是操作系统中实现功能的代码块，也叫软件
进程：正在运行中的程序
多进程：多个程序同时运行
并发：cpu在执行程序时，会将时间划分为一个一个时间片段，这些时间片段在同一时间只能有一个线程在执行，多个线程之间，时间片段是走走停停断断续续的，但是宏观上来看这些时间类似是“一起执行”，我们将多个线程同时执行称之为并发线程并发出现在多线程中
线程创建方式：
1.继承Thread类，重写Thread类中的run方法（线程任务体），在主方法中调用线程方法start()方法启动线程
2.继承Runnable接口（任务接口），该接口中有一个run方法是任务体，创建线程，将任务作为线程的参数传进来，然后调用线程的start()方法来启动线程
3.使用FutureTask来创建线程，用Callable来创建任务，然后将FutrueTask作为参数放到线程里，启动线程。
线程分类：前台线程、后台线程（守护线程）
前台线程：我们所创建的线程默认都为前台线程（注：main方法也是前台线程）
后台线程（守护线程）：当所有前台线程结束时，守护线程自动结束
线程安全：
当多个线程同时使用同一资源时，容易出现线程安全问题，此时我们需要用线程同步来解决线程安全问题
如何进行线程同步：①同步方法（在方法上使用synchronized关键字进行锁定）②同步代码块（在代码块加锁）
锁对象：要执行线程同步的对象，可以是任意对象，但是要求每个线程看到的锁对象 必须是同一个才可以，否则起不到线程同步的作用
线程的状态：
1）新建状态 new 创建线程的
2）就绪状态 .start()
3）运行状态 .run()
4）阻塞状态
a.等待阻塞 .wait()
b.同步阻塞 锁对象被其他线程占用，当前线程等待其他线程释放 锁对象
c.其它阻塞 .sleep() .join()
5）死亡状态 线程体执行完毕，线程死亡
方法：
①void sleep()：Thread类提供的一个静态方法
②void sleep(long ms)：表示让当前线程休眠long毫秒，在此过程中，如果该线程被打断，会抛出InterruptedException，如果休眠过程一直没有被打断，时间一到，线程的休眠状态自动解除，等待cpu的到来，一旦获得cpu，代码便继续执行
③void interrupt()：手动打断某个正在休眠的线程，一旦调用该方法，则正在休眠的线程会抛出InterruptedException
④int getPriority()：获取线程优先级，1-10,10最大，1最小，5正常，理论上，优先级越高，获取cpu概率越高
⑤void setPriority(int a)：设置某个线程的优先级，理论上优先级越高，获取cpu的概率越大，实际上可能并非如此
⑥Thread currentThread()：线程提供的一个静态方法，用来获取当前正在运行的线程
⑦void join()：等待某个线程结束，哪个线程调用该方法，就等待哪个线程，该线程结束后才会继续执行本线程后续代码
⑧void join(long mile)：mile最多等待时间，不常用
⑨void setDaemon(boolean on)：将线程设置为守护线程
⑩boolean isAlive()：判断线程是否存活
⑪String getName()：获取线程名称
⑫long getId()：获取线程优先级
⑬boolean isDaemon()：判断是否为守护线程
举例
例一：通过Thread类重写run方法来创建线程并启动
public class ThreadDemo {
public static void main(String[] args) {
Thread t=new Thread() {
public void run() {
for(int i=0;i<500;i++) {
System.out.println(getName()+":"+i);
}
}
};
Thread t1=new Thread(new Runnable() {
public void run() {
for(int i=0;i<500;i++) {
System.out.println("中国首富");
}
}
});
t.start();
t1.start();
}
}
运行结果：可见中国首富与序号无顺序输出，因结果冗长此处不进行输出示例
例二：通过继承Thread类并重写run方法来创建并启动线程
public class ThreadDemo1 {
public static void main(String[] args) {
MyTask mt=new MyTask();
MyTask1 mt1=new MyTask1();
mt.start();
mt1.start();
}
}
class MyTask extends Thread{
public void run() {
for(int i=0;i<500;i++) {
System.out.println("中国");
}
}
}
class MyTask1 extends Thread{
public void run() {
for(int i=0;i<500;i++) {
System.out.println("首富");
}
}
}
运行结果：可见中国与首富无顺序输出，因结果冗长此处不进行输出示例
例三：通过继承Runnable接口重写run方法之后将对象作为参数传入到Thread类中来创建并启动线程
public class ThreadDemo2 {
public static void main(String[] args) {
MyRunnable m=new MyRunnable();
Thread t=new Thread(m);
MyRunnable1 m1=new MyRunnable1();
Thread t1=new Thread(m1);
t.start();
t1.start();
}
}
class MyRunnable implements Runnable{
public void run() {
for(int i=0;i<500;i++) {
System.out.println("中国");
}
}
}
class MyRunnable1 implements Runnable{
public void run() {
for(int i=0;i<500;i++) {
System.out.println("首富");
}
}
}
运行结果：可见中国与首富无顺序输出，因结果冗长此处不进行输出示例
例四：通过FutureTask类与Callable接口并重写call方法后将FutureTask类对象作为参数传入入Thread类对象中来创建并启动线程
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThreadDemo4 {
public static void main(String[] args) {
FutureTask<String> f=new FutureTask<String>(new Callable<String>() {
public String call() throws Exception {
for(int i=0;i<500;i++) {
System.out.println("中国");
}
return null;
}
});
FutureTask<String> f1=new FutureTask<String>(new Callable<String>() {
public String call() {
for(int i=0;i<500;i++) {
System.out.println("首富");
}
return null;
}
});
Thread t=new Thread(f);
Thread t1=new Thread(f1);
t.start();
t1.start();
}
}
运行结果：可见中国与首富无顺序输出，因结果冗长此处不进行输出示例
例五：“我心永恒”线程测试
public class ThreadDemo5 {
public static void main(String[] args) {
System.out.println("main方法开始");
Thread rose=new Thread() {
public void run() {
for(int i=0;i<10;i++) {
System.out.println("let me go");
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("jump");
}
};
Thread jack=new Thread() {
public void run() {
while(true) {
System.out.println("you jump,i jump");
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
jack.setDaemon(true);
rose.start();
jack.start();
System.out.println("main方法结束");
while(rose.isAlive()) {
System.out.println("剧终");
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行结果：main方法开始
main方法结束
剧终
let me go
you jump,i jump
let me go
you jump,i jump
剧终
let me go
you jump,i jump
剧终
剧终
you jump,i jump
let me go
let me go
you jump,i jump
剧终
剧终
you jump,i jump
let me go
let me go
剧终
you jump,i jump
剧终
let me go
you jump,i jump
let me go
剧终
you jump,i jump
you jump,i jump
let me go
剧终
jump
you jump,i jump
剧终
you jump,i jump