1.一个进程可以理解为一个应用程序，一个进程通常包括多个线程。进程可以理解为一个公司，线程理解为公司的员工。
2.进程A与进程B之间内存独立不共享线程A与线程B之间堆与方法区内存共享，但是栈是独立的，一个线程拥有一个栈！！！
3.单核cpu不能实现真正的多线程并发，但是可以“模拟多线程并发”，例如它可以使多个线程来回切换，这样一来给人的感觉像是并发的。
4.start方法会启动另一个分支线程，而run方法不会。
两种方式：
package com.javastudy.example11;
/*
1.一个进程可以理解为一个应用程序，一个进程通常包括多个线程。
进程可以理解为一个公司，线程理解为公司的员工：
2.进程A与进程B之间内存独立不共享
线程A与线程B之间堆与方法区内存共享，但是栈是独立的，一个线程拥有一个栈！！！
3.单核cpu不能实现真正的多线程并发，但是可以“模拟多线程并发”，例如它可以使多个线程来回切换，
这样一来给人的感觉像是并发的。
4.start方法会启动另一个分支线程，而run方法不会。
*/
public class Thread01 extends Thread{
public static void main(String[] args) {
//主线程
//方法一（继承Thread）
MyThread thread = new MyThread();
//启动另一个线程
thread.start();
for(int i=0;i<100;i++){
System.out.println("线程一执行"+i);
}
//方法二（实现Runable接口）
System.out.println("======方法二=============");
MyRun myrun=new MyRun();
Thread t=new Thread(myrun);
t.start();
for(int i=0;i<100;i++){
System.out.println("线程一执行"+i);
}
}
}
class MyThread extends Thread{
//分支线程
public void run(){
for(int i=0;i<100;i++){
System.out.println("线程二执行"+i);
}
}
}
//方法二 面向接口编程，常用
class MyRun implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println("线程二执行"+i);
}
}
}
获取线程名字，修改名字，获取对象：
package com.javastudy.example11;
public class Thread02 {
public static void main(String[] args) {
Thread t=new Thread(new MyRun02());
t.start();
//获取名字
System.out.println("t1线程初始名字为-------"+t.getName());
for(int i=0;i<10;i++){
if(i==1){
//设置名字
t.setName("t1线程名字已被修改");
}
System.out.println(t.getName()+"-----"+i);
}
Thread t2=new Thread(new MyRun02());
//获取名字
System.out.println("t2线程初始名字为-------"+t2.getName());
//获取当前对象
System.out.println("将t2赋值为当前对象，即main");
t2=Thread.currentThread();
System.out.println("此时，t2线程名字为-------"+t2.getName());
MyThread02 myt=new MyThread02();
myt.start();
MyThread02 myt2=new MyThread02();
myt2.start();
}
}
class MyRun02 implements Runnable{
@Override
public void run() {
System.out.println("=================线程2启动=====================");
System.out.println("当前线程为");
}
}
class MyThread02 extends Thread{
public void run(){
Thread x1=Thread.currentThread();
System.out.println("当前线程为"+x1.getName());
x1.setName("change");
System.out.println("修改后为"+x1.getName());
/* for(int i=0;i<100;i++){
System.out.println("当前线程对象名字为"+i);
}*/
}
}
线程的休眠与唤醒
package com.javastudy.example11;
public class Thread03 {
public static void main(String[] args) {
MyRun03 myRun03 = new MyRun03();
Thread t=new Thread(myRun03);
t.start();
System.out.println("------主线程休眠3s-------");
try {
t.sleep(1000*3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------主线程休眠自动结束-------");
// System.out.println("强制分支休眠结束，通过异常机制interrupt");
// 方式一 t.interrupt();
// 方式二 t.stop();
//合理方式
myRun03.flag=false;
}
}
class MyRun03 implements Runnable{
boolean flag=true;
@Override
public void run() { //只能使用try catch，子类只能抛出更少的异常
System.out.println("------分支线程休眠5s-------");
if(flag){
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------分支线程休眠结束-------");
}}
}
休眠-唤醒 运行截图
