在java 虚拟机进程中，执行程序代码的任务是由线程来完成的，每个线程都有一个独立的程序计算器和方法调用栈（method invocation stack）
每当用java命令启动一个Java虚拟机进程是，Java虚拟机都会创建一个主程序，该程序从程序入口main（）方法开始执行。
进程：应用程序的执行实例，有独立的内存空间和系统资源，
线程：cpu调度和分派的基本单位，进程中执行运算的最小单位，可完成一个独立的顺序控制流程
多线程：如果在一个进程中同时运行了多个线程，用来完成不同的工作，多个线程交替占用cpu资源，而非真正的执行
多线程的好处：
1.充分利用cpu的资源
2.简化编程模型
3.带来良好的用户体验
用户还可以创建自己的线程，它将和主线程并发运行，创建有两种方式：
继承Thread类
1.编写简单，可直接操作线程
2.适用于单继承
实现Runnable接口
1.避免单继承局限性
2.便于共享资源
Thread类
java提供了Java.lang.Thread类支持多线程编程
主线程
main（）方法即为主线程入口
产生其他子线程的线程
必须最后完成执行，
因为它执行各种关闭动作
run（）方法:包含线程运行时执行的代码
start（）方法：用于启动线程
用户的线程类只需要继承Thread类 覆盖Thread类的run（）方法即可
线程字段：
MNX_PRIORITY： 线程可以具有最高优先级
MIN_PRIORITY: 线程可以具有的最低优先级
NORM_PRIORITY： 分配给线程的默认优先级
void join()： 等待线程终止。
void run() ： 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
void setName(String name) ： 改变线程名称，使之与参数 name 相同。
void setPriority(int newPriority) ： 更改线程的优先级。
static void sleep(long millis) ： 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
void start() ： 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
static void yield() ： 暂停当前正在执行的线程对象，并执行其他线程。
Boolean isAlive(): 测试线程是否处于活动状态
void interrrupt()： 中断线程
线程对象调用start()方法和调用run()方法的区别
run(): 只有主线程一条执行路径
start(): 多条执行路径，主线程和子线程并行交替执行
---继承Thread类创建线程
示例--
public class Hello extends Thread{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(i+"."+"你好，来自线程"+Thread.currentThread().getName());
}
}
}public class MyThread {
public static void main(String[] args) {
Hello thread1=new Hello();
thread1.start();
Hello thread2=new Hello();
thread2.start();
}
}--实现Runnable接口创建线程
示例---
public class Hello implements Runnable{
@Override
public void run() {
for(int i=0;i<10;i++)
{
System.out.println(i+"."+"你好，来自线程"+Thread.currentThread().getName());
}
}public class MyRunnable {
public static void main(String[] args) {
Hello hello=new Hello();
Thread thread1=new Thread(hello);
thread1.start();
Thread thread2=new Thread(hello);
thread2.start();
}
}----线程的运行状态
--线程的休眠
示例--
public class ThreadDemo {
public void bySec(long s) {
for (int i = 1; i <=s; i++) {
System.out.println(i+"秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}public class Wait {
public static void main(String[] args) {
ThreadDemo t=new ThreadDemo();
System.out.println("Wait");
t.bySec(5);
System.out.println("start");
}
}---线程的强制运行
示例--
public class MyThread implements Runnable{
@Override
public void run() {
for(int i=1;i<=10;i++)
{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"运行"+i);
}
}
}public class ThreadJoinDemo {
public static void main(String[] args) {
System.out.println("线程强制执行");
Thread t=new Thread(new MyThread());
t.start();
for(int i=1;i<=10;i++) {
if(i==5) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"运行"+i);
}
}
}--线程的礼让
示例--
public class MyThread implements Runnable{
@Override
public void run() {
for(int i=1;i<=5;i++) {
System.out.println(Thread.currentThread().getName()+"正在运行"+i);
if(i==3) {
System.out.println("线程礼让");
Thread.yield();
}
}
}
}public class ThreadYieldDemo {
public static void main(String[] args) {
Thread t1=new Thread(new MyThread(),"线程A");
Thread t2=new Thread(new MyThread(),"线程B");
t1.start();
t2.start();
}
}线程的同步实现
示例--
public class Printer {
public synchronized void printer1()
{
System.out.print("j");
System.out.print("a");
System.out.print("v");
System.out.println("a");
}
public synchronized void printer2()
{
System.out.print("编");
System.out.println("程");
}
}public class MyThread1 implements Runnable{
public Printer printer;
@Override
public void run() {
for(int i=1;i<=20;i++)
{
printer.printer1();
}
}
}public class MyThread2 implements Runnable{
public Printer printer;
@Override
public void run() {
for(int i=1;i<=20;i++)
{
printer.printer2();
}
}
}public class MyMain {
public static void main(String[] args) {
MyThread1 m1=new MyThread1();
Thread t1=new Thread(m1);
MyThread2 m2=new MyThread2();
Thread t2=new Thread(m2);
Printer printer=new Printer();
m1.printer=printer;
m2.printer=printer;
t1.start();
t2.start();
}
}通过在方法声明中加入synchronized关键词来声明同步方法
访问修饰符 synchronized 返回类型 方法名 （参数类型）{//方法体}
或者
synchronized 访问修饰符 返回类型 方法名 （参数类型）{//方法体}
