多进程：在操作系统中（同时）运行多个任务（程序）
多线程：在同意应用程序中有多个顺序流（同时）执行
线程的执行过程
一、创建线程的方法：
（1）定义一个线程类，它继承类Thread并重写其中的方法run()，方法()称为线程体，由于java只支持单继承，所以这种方法定义的类不能再继承其他类
代码：
class FirstThread extends Thread{
public void run(){
for(int i = 0;i < 100;i++){
System.out.println("firstThread-->" + i);
}
}
}
class Test{
public static void main(String args[]){
//生成线程类的对象
FirstThread ft = new FirstThread();//ft属于一个线程对象
//启动线程
ft.start();//start为继承Thread得来
for(int i = 0;i < 100;i++){
System.out.println("main-->" + i);}
//ft.run();千万不能这样写
}//主函数是一个线程，线程对象启动的为第二个线程，第三个为垃圾回收线程
}
运行后结果：
main-->0
main-->1
main-->2
main-->3
main-->4
main-->5
main-->6
main-->7
main-->8
main-->9
main-->10
main-->11
main-->12
main-->13
main-->14
main-->15
main-->16
main-->17
main-->18
main-->19
main-->20
main-->21
main-->22
main-->23
main-->24
main-->25
main-->26
main-->27
main-->28
main-->29
main-->30
main-->31
main-->32
main-->33
main-->34
main-->35
main-->36
main-->37
main-->38
main-->39
main-->40
main-->41
main-->42
main-->43
main-->44
main-->45
main-->46
main-->47
main-->48
main-->49
main-->50
main-->51
main-->52
main-->53
main-->54
main-->55
main-->56
main-->57
main-->58
main-->59
main-->60
main-->61
main-->62
main-->63
main-->64
main-->65
main-->66
main-->67
main-->68
main-->69
main-->70
main-->71
main-->72
main-->73
main-->74
main-->75
main-->76
main-->77
main-->78
main-->79
main-->80
main-->81
main-->82
main-->83
main-->84
main-->85
main-->86
main-->87
main-->88
main-->89
main-->90
main-->91
main-->92
main-->93
main-->94
firstThread-->0
firstThread-->1
firstThread-->2
firstThread-->3
firstThread-->4
firstThread-->5
firstThread-->6
firstThread-->7
firstThread-->8
firstThread-->9
firstThread-->10
firstThread-->11
firstThread-->12
firstThread-->13
firstThread-->14
firstThread-->15
firstThread-->16
firstThread-->17
firstThread-->18
firstThread-->19
firstThread-->20
firstThread-->21
firstThread-->22
firstThread-->23
firstThread-->24
firstThread-->25
firstThread-->26
firstThread-->27
firstThread-->28
firstThread-->29
firstThread-->30
firstThread-->31
firstThread-->32
firstThread-->33
firstThread-->34
firstThread-->35
firstThread-->36
firstThread-->37
firstThread-->38
firstThread-->39
firstThread-->40
firstThread-->41
firstThread-->42
firstThread-->43
firstThread-->44
firstThread-->45
firstThread-->46
firstThread-->47
firstThread-->48
firstThread-->49
firstThread-->50
firstThread-->51
firstThread-->52
firstThread-->53
firstThread-->54
firstThread-->55
firstThread-->56
firstThread-->57
firstThread-->58
firstThread-->59
firstThread-->60
firstThread-->61
firstThread-->62
firstThread-->63
firstThread-->64
firstThread-->65
firstThread-->66
firstThread-->67
firstThread-->68
firstThread-->69
firstThread-->70
firstThread-->71
firstThread-->72
firstThread-->73
firstThread-->74
firstThread-->75
firstThread-->76
firstThread-->77
firstThread-->78
firstThread-->79
firstThread-->80
firstThread-->81
firstThread-->82
firstThread-->83
firstThread-->84
firstThread-->85
firstThread-->86
firstThread-->87
firstThread-->88
firstThread-->89
firstThread-->90
firstThread-->91
firstThread-->92
firstThread-->93
firstThread-->94
firstThread-->95
firstThread-->96
firstThread-->97
firstThread-->98
firstThread-->99
main-->95
main-->96
main-->97
main-->98
main-->99
说明：两个循环运行在不同的线程中（两个循环执行的顺序不一定，抢占cpu，没有规律）
（2）提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体
代码：
class RunnableImpl implements Runnable{
public void run(){
for(int i = 0;i < 100;i++){
System.out.println("Runnable-->" + i);}//Runnable的实现类
}
}
class Test{
public static void main(String args[]){
//生成一个Runnable接口实现类的对象
RunnableImpl ri = new RunnableImpl();
//生成一个Thread对象，并将Runnable接口实现类的对象作为参数传递给该Thread对象
Thread t = new Thread(ri);
//通知Thread对象执行
t.start();
}
}
运行结果：
D:\>java Test
Runnable-->0
Runnable-->1
Runnable-->2
Runnable-->3
Runnable-->4
Runnable-->5
Runnable-->6
Runnable-->7
Runnable-->8
Runnable-->9
Runnable-->10
Runnable-->11
Runnable-->12
Runnable-->13
Runnable-->14
Runnable-->15
Runnable-->16
Runnable-->17
Runnable-->18
Runnable-->19
Runnable-->20
Runnable-->21
Runnable-->22
Runnable-->23
Runnable-->24
Runnable-->25
Runnable-->26
Runnable-->27
Runnable-->28
Runnable-->29
Runnable-->30
Runnable-->31
Runnable-->32
Runnable-->33
Runnable-->34
Runnable-->35
Runnable-->36
Runnable-->37
Runnable-->38
Runnable-->39
Runnable-->40
Runnable-->41
Runnable-->42
Runnable-->43
Runnable-->44
Runnable-->45
Runnable-->46
Runnable-->47
Runnable-->48
Runnable-->49
Runnable-->50
Runnable-->51
Runnable-->52
Runnable-->53
Runnable-->54
Runnable-->55
Runnable-->56
Runnable-->57
Runnable-->58
Runnable-->59
Runnable-->60
Runnable-->61
Runnable-->62
Runnable-->63
Runnable-->64
Runnable-->65
Runnable-->66
Runnable-->67
Runnable-->68
Runnable-->69
Runnable-->70
Runnable-->71
Runnable-->72
Runnable-->73
Runnable-->74
Runnable-->75
Runnable-->76
Runnable-->77
Runnable-->78
Runnable-->79
Runnable-->80
Runnable-->81
Runnable-->82
Runnable-->83
Runnable-->84
Runnable-->85
Runnable-->86
Runnable-->87
Runnable-->88
Runnable-->89
Runnable-->90
Runnable-->91
Runnable-->92
Runnable-->93
Runnable-->94
Runnable-->95
Runnable-->96
Runnable-->97
Runnable-->98
Runnable-->99
第二种方法更好
二、线程的简单控制方法
1.中断线程
Thread.sleep()//停止运行的时间大于休眠时间（休眠结束后重新开始争夺cpu）
代码：
class RunnableImpl implements Runnable{
public void run(){
for(int i = 0;i < 100;i++){
System.out.println("Runnable-->" + i);}//Runnable的实现类
if(i == 50){
Thread.sleep(2000);
}
}
}
运行结果：
D:\>javac RunnableImpl.java
RunnableImpl.java:6: 未报告的异常 java.lang.InterruptedException；必须对其进行捕
捉或声明以便抛出
Thread.sleep(2000);
^
1 错误
修改后代码：
class RunnableImpl implements Runnable{
public void run(){
for(int i = 0;i < 100;i++){
System.out.println("Runnable-->" + i);//Runnable的实现类
if(i == 50){
try{
Thread.sleep(2000);
}
catch(Exception e){
System.out.println(e);
}
}
}
}
}
Thread.yield()
自动让出cpu后再次争夺cpu
2.设置线程的优先级（仅仅是增加进程的运行概率，不是一定运行）
getPriority()
setPriority()
代码：
class Test{
public static void main(String args[]){
//生成一个Runnable接口实现类的对象
RunnableImpl ri = new RunnableImpl();//代表线程体
//生成一个Thread对象，并将Runnable接口实现类的对象作为参数传递给该Thread对象
Thread t = new Thread(ri);//代表一个线程
//现场的最大优先级10，最小1，可以使用Thread所提供的静态变量来设置现场的优先级
t.setPriority(Thread.MAX_PRIORITY);//最大优先级
t.setPriority(Thread.MIN_PRIORITY);//最小优先级
System.out.println(t.getPriority());//打印出Thread的默认优先级
//通知Thread对象执行
t.start();
}
}
三、多线程数据安全
代码：
class MyThread implements Runnable{
int i = 100;
public void run(){
while(true){
synchronized(this){
//程序锁，只进行线程a，结束后再执行线程b保证安全
// Thread.currentThread();获取当前代码在那个线程中运行
System.out.println(Thread.currentThread().getName() + i);
i--;
Thread.yield();
if(i < 0){
break;
}
}
}
}
}
class Test{
public static void main(String args[]){
MyThread myThread = new MyThread();
//生成两个Thread对象，但两个Thread共用一个线程体mytThread
Thread t1 = new Thread(myThread);
Thread t2 = new Thread(myThread);
//每一个线程都有名字，可以通过Thread对象的setName()设置线程名字，也可以使用getName获取线程方法
//分别启动两个线程
t1.setName("线程a");
t2.setName("线程b");
t1.start();
t2.start();
}
}
四、线程的同步
