并发与并行：
并发:多个任务交替执行 （一个人吃两个馒头，两个交替啃）
并行：同时执行。（n个人吃n个馒头） 速度快些。
线程与进程：
进程：进入到内存中的程序叫进程。
线程：
主线程：
执行主方法（main）的线程
单线程程序：java程序中只有一个线程，从main方法开始，从上到下依次执行。
jvm执行main方法，main方法会进入栈内存，
然后jvm找到操作系统开辟一条main方法通向cpu的执行路径，
cpu就可以通过这个路径执行main方法，这个路径叫main（主）线程。
多线程：
java程序属于抢占式调度，哪个线程高，哪个线程就优先执行，同一级别随机执行。
创建多线程程序的第一种方式：
java.lang.thread 类：是描述线程的类，想实现多线程程序，就必须继承该类。
实现步骤：
1、创建thread类的子类。
2、子类重写run方法， 来设置线程任务。
3、创建子类对象，调用start（）方法，开启新的线程，执行run方法。
结果是：两个线程并发执行。
我要评论public class mythread extends thread {
@override
public void run() {
for (int i=0;i<3;i++){
system.out.println("run->"+i);
}
}
}
public class threaddemo {
public static void main(string[] args) {
mythread mythread=new mythread();
mythread.start();
for (int i=0;i<3;i++){
system.out.println("main->"+i);
}
main->0
run->0
main->1
run->1
main->2
run->2
}
}
多线程运行原理：
new mythread的时候，又开辟了一条通向cpu的新路径，来执行run方法。
此时，对cpu而言，就有了两条执行路径。
main线程和新线程一起抢夺cpu的执行权。
多线程内存分析：
开始执行程序时，开辟一块栈内存，main方法入栈。
此时，如果直接调用run方法的话，也是在这块栈内存执行run（），也就是仍然
是main线程程序（单线程）程序。
而如果调用的是start（），会另外开辟一块栈空间，run（）入栈执行。
thread类的常用方法：
获取线程名称：
1、thread类的方法，getname（）；
2、获取当前正在执行的线程 static thread currentthead(),然后用getname();
第一种：
public class mythread extends thread {
@override
public void run() {
system.out.println(getname());
}
}
public static void main(string[] args) {
new mythread().start();
new mythread().start();
//thread-0
// thread-1
}
第二种：
public static void main(string[] args) {
system.out.println(thread.currentthread().getname());
//main
}
}
设置线程名称：
1、void setname(string name) 2、设置带参构造函数
sleep方法：
public static void sleep(long ...) :使当前正在执行的线程以指定毫秒暂停。
public static void main(string[] args) {
for (int i=0;i<5;i++){
system.out.println(i);
try {
thread.sleep(1000);
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
创建多线程程序的第二种方式：
实现runnable接口：
java.lang.runnable. 实现类必须定义run的无参方法。
java.lang.thread 类的构造方法：
1、thread(runnable target) 分配新的thread对象。
2、thread(runnable target,string name)。
实现步骤：
1、创建runnable接口的实现类。
2、重写run方法，设置线程任务。
3、创建实现类的对象，用含有runnable接口的构造函数创建thread类对象。
4、用start方法，开启新线程执行run（）；
public class runnableclass implements runnable {
@override
public void run() {
for (int i=0;i<5;i++){
system.out.println(
thread.currentthread().getname()
+"->"+i
);
}
}
}
public static void main(string[] args) {
runnableclass runnable=new runnableclass();
thread thread=new thread(runnable);
thread.start();
for (int i=0;i<5;i++){
system.out.println(
thread.currentthread().getname()
+"->"+i
);
}
}
两种实现多线程方法的区别：
实现runnable接口实现多线程的好处：
1、避免单继承的局限性：
继承了thread类就不能继承其他类了，而使用接口的方式还可以继承其他类。
2、增强程序的扩展性，降低了程序的耦合性（解耦）：
用实现runnable接口的方式，把设置线程任务和开启线程进行分离（解耦 ）
匿名内部类实现多线程：
作用：
简化代码，把实现类实现接口，重写方法，创建实现类方法统一完成。
格式： new 父类/接口（）{重写方法}；
public static void main(string[] args) {
new thread() {
@override
public void run() {
for (int i=0;i<5;i++){
system.out.println(currentthread().getname());
}
}
}.start();
new thread(new runnable() {
@override
public void run() {
for (int i=0;i<5;i++){
system.out.println(thread.currentthread().getname());
}
}
}).start();
}
如对本文有疑问， 点击进行留言回复！！
深入理解java中的static关键字（语法和使用方法特点等）
quartz框架定时任务整合springboot报空指针异常解决
java file获取功能，file.toString()可以拿到路径
荐 【SpringMVC】001-SpringMVC入门程序（超详细版）
网友评论