线程：
进程是指在系统中正在运行的一个应用程序，线程是比进程更小的执行单位。
线程是程序执行的一条路径，一个进程中可以包含多条线程，多线程并发执行可以提高程序的效率。
多线程并行和多线程并发的区别：
并行是指在多核CPU下，多个任务同时运行。
并发是指在一个CPU下，多个任务轮流交替执行，每个任务执行的时间都很短，使人感觉多个任务是同时运行的。即从宏观上看，多个任务是同时进行，但从微观上看，CPU在同一时间内只能执行一个任务。
Java程序的运行原理：
Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个”主线程“，然后主线程去调用某个类的main方法。
jvm支持多线程：启动了主线程、垃圾回收器线程。
多线程实现方式：
1. 继承Thread类，并重写run方法
2. 实现Runnable接口
Thread类：
publicclass Thread extends Object implements Runnable，是lang包下的类，不需要导入，直接使用。
构造方法：
public Thread(Runnable target)分配新的 Thread 对象。参数target 是其 run 方法被调用的对象。
public Thread(String name)分配新的 Thread 对象。参数就是给该线程起一个名字。
主要方法：
publicvoid start()：使该线程开始执行；Java 虚拟机自动调用该线程的 run 方法。一个线程类对象只能调用一次start方法，否则会出现异常（java.lang.IllegalThreadStateException）。
publicvoid run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 Thread的子类应该重写该方法，因为Thread类中的run方法没有具体内容，run方法中写的是要执行的代码。
public final String getName()返回该线程的名称。
public final void setName(Stringname)改变线程名称，使之与参数name 相同。
public static Thread currentThread()返回对当前正在执行的线程对象的引用。静态方法，直接用类名调用。
public static void sleep(longmillis) throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。静态方法，直接用类名调用。该方法是自动睡眠指定的时间，然后自动唤醒。
public final void setDaemon(booleanon)将该线程标记为守护线程或用户线程。该方法必须在启动线程前调用。当正在运行的线程都是守护线程时，Java 虚拟机退出。参数如果是true，就表示把该线程设置为守护线程。非守护线程终止时，守护线程也就终止了。
public final void join() throwsInterruptedException等待该线程终止。相当于插队。
public final void join(long millis) throws InterruptedException等待该线程终止的时间最长为 millis 毫秒。插队时间为传输的参数毫秒值。
public final void setPriority(int newPriority)更改线程的优先级。最小是1（MIN_PRIORITY），最大是10（MAX_PRIORITY），如果不设置，默认优先级为5。
实现线程代码示例：
package com.thread;
public class Lianxi1 {
publicstatic void main(String[] args) {
MyThreadt = new MyThread();//创建线程的子类对象
//t.run();//直接调用run方法，就相当于普通的方法一样，所以就先执行run方法，即打印输出100000次******，执行结束后，再执行主线程中的for循环。
t.start();//开启线程，自动调用run方法，和主线程交替执行，所以输出*****和输出##交替执行，且每次运行的结果不尽相同，输出结果依赖于当前CPU资源的使用情况。
//t.start();//调用两次start方法会报异常
for(inti = 0;i<1000;i++){//主线程中的语句
System.out.println("###");
}
}
}
class MyThread extends Thread{
publicvoid run(){//将要执行的代码
for(inti = 0;i<1000;i++){
System.out.println("**************");
}
}
}
sleep方法代码示例：
new Thread(new Runnable(){
publicvoid run(){
for(inti = 0;i<20;i++){
try{
Thread.sleep(500);
}catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("bb");
}
}
}).start();
setDaemon()方法代码示例：
package com.thread;
public class Lianxi7 {
publicstatic void main(String[] args) {
Threadt1 = new Thread("非守护线程"){
publicvoid run(){
for(inti = 0;i<3;i++){
System.out.println("aaaaaaaaaa");
}
}
};
Threadt2 = new Thread("守护线程"){
publicvoid run(){
for(inti = 0;i<100;i++){
System.out.println(i);
}
}
};
t1.start();
t2.setDaemon(true);//将t2设置为守护线程，该方法必须在开启线程之前使用
t2.start();//非守护线程执行完毕之后，守护线程有一个缓冲时间，然后才会停止守护线程。
}
}
join方法代码示例：
public static void main(String[] args) {
finalThread t1 = new Thread(){
publicvoid run(){
for(int i = 0;i<20;i++){
System.out.println("aaaaaaaa"+i);
}
}
};
Threadt2 = new Thread(){
publicvoid run(){
for(int i = 0;i<10;i++){
if(i== 3){
try{
t1.join();//当i=3时，t1线程就插队执行，直到执行完毕，再继续执行t2线程
//t1.join(1);//当i=3时，t1线程插队执行一毫秒，一毫秒之后这两个线程再交替执行。
}catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("b"+i);
}
}
};
t1.start();
t2.start();
}
join无参方法运行结果如图：
join（long millis）方法运行结果图：
Runnable接口：
publicinterface Runnable，Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
方法：
void run()：使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。
Runnable只有一个run方法，没有start方法，所以想要开启线程，需要使用Thread的一个构造方法：public Thread(Runnable target)，将接口实现类对象传进去，获得一个Thread对象，然后调用Thread的start方法，开启线程。
代码示例：
packagecom.thread;
publicclass Lianxi2 {
public static void main(String[] args) {
MyRunnable m = new MyRunnable();//创建线程目标执行类对象
Thread t = new Thread(m);//使用Thread的构造方法，传入的参数是Runnable的实现类对象，然后就可以调用Thread的start方法开启线程（使用线程目标执行类对象创建线程对象）
t.start();//开启线程
for(int i = 0;i<1000;i++){
System.out.println("###");
}
}
}
classMyRunnable implements Runnable{
public void run() {
for(int i = 0;i<1000;i++){
System.out.println("**************");
}
}
}
使用匿名内部类实现多线程的两种方式：
代码示例：
通过匿名内部类创建Thread对象：
public static void main(String[] args) {
newThread(){//创建匿名内部类对象
public void run(){//重写run方法
for(int i = 0;i<1000;i++){
System.out.println("aaaaaaaaaaaaaaaa");
}
}
}.start();//开启线程（绿色阴影部分是Thread的子类对象，直接调用start对象）
}
通过匿名内部类创建Runnable实现类对象：
public static void main(String[] args) {
new Thread(new Runnable(){//使用匿名内部类创建接口实现类对象，再把它作为参数创建Thread对象
public void run() {
for(inti = 0;i<1000;i++){
System.out.println("bb");
}
}}).start();//创建好了Thread子类对象调用start方法开启线程
}//绿色阴影部分是接口的实现类对象，然后作为Thread构造方法的参数，创建得到Thread对象，再调用start方法开启线程。
两种实现多线程的方法的区别：
继承Thread类：创建子类对象，直接调用start方法即可开启线程并自动调用run方法。
好处：可以直接获得start方法，代码简单。
弊端：如果子类有了父类，再想使用该方法就不可以继承Thread，因为java中的继承是单继承，一个子类只能继承一个父类。
实现Runnable接口：创建一个接口的实现类对象，然后作为参数传入Thread的构造方法，得到一个Thread对象，用该对象调用Thread类的start方法，start自动调用本类中的run方法，在run方法中会判断一下runnable对象是否为空，如果不为空，那就调用接口子类对象中的run方法。否则就执行Thread子类对象的run方法（第一种多线程实现方式，继承Thread的run方法时，编译看Thread，运行看子类的run）。
好处：即使有了父类也可以实现该接口，并且可以实现多个接口。
弊端：实现类对象需要作为参数，创建一个Thread对象，使用Thread的start方法开启线程，代码复杂。
设置线程名称的方法：
1. 通过Thread有参构造方法：public Thread(String name)
2. 使用Thread的setName方法：public final void setName(Stringname)
获取线程名称的方法：
使用Thread类的getName方法，但是当使用接口来实现线程时，在实现类对象内部不能直接调用getName方法。
需要使用Thread类的静态方法currentThread来获取当前正在执行的线程对象，然后再使用getName方法，获取县城名称，如果需要设置名称，也需要获取当前线程对象然后再使用setName设置名称。
代码示例：
newThread(new Runnable(){
public void run() {
Thread.currentThread().setName("第二个线程");//获取当前正在执行的线程 System.out.println(Thread.currentThread().getName()+"bbbbbbbbbb" }
}).start();
2205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
