java-多线程
2021-05-05 19:29
标签：str rri 主程序 read main方法 oid main package 名称 并发性是一系列性能技术，专注于减少等待 如果你的程序中的一个任务由于程序控制之外的某些条件（通常是I/O）而无法继续，我们会说任务或线程阻塞 进程和线程 线程的调度: 主线程 单线程程序 创建线程累 创建子类： 实例化子类并调用start方法： 结果 分析， 简单而言： Thread累 获取线程名字1111 创建Thread子累： 实例化： 获取线程名字2222 子类修改 简化语句:链式编程 结果： 设置线程名称 setName 子类: 线程睡眠方法：sleep 静态方法，直接调用 创建线程的第二种方式 实现接口累，必须重载 继承Thread和实现Runnable接口的区别 我们可以按照不同的需求去将实现累修改，传入不同的实现类给Thread的构造方法就行 建议使用Runnable 使用匿名内部类方式实现线程的创建 java-多线程 标签：str rri 主程序 read main方法 oid main package 名称 原文地址：https://www.cnblogs.com/java-quan/p/13022618.html
分时调用
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
抢占式调度
优先让优先级较高的线程使用CPU,如果线程的优先级相同，那么会随机选择一个（线程随机性），
java使用的为抢占式调度
/*
主程序:执行主方法的线程
单线程程序:java程序中只有一个线程
执行从main方法开始,从上到下一次执行
*/
public class Demo1Test {
public static void main(String[] args) {
Person p1 = new Person("xiaoqiang");
p1.run();
Person p2 = new Person("wacai");
p2.run();
}
}
/*
创建多线程程序的第一种方式，创建Thread的子类
实现多线程程序，必须继承Thread累
实现步骤
1创建一个子类
2再Thread得子类中重写run方法，设置线程任务
3创建子类实例对象
4调用Thread累得方法start，开启心得线程，。执行run方法
void start() 使线程开始执行，JVM调用该线程得run方法
结果使两个线程并发运行，当前线程（main）线程，和另外一个线程
多次启动同一个线程使非法得，特别是当线程已经执行接受，不能在重新启动
java程序属于抢占式调度，那个线程优先级高，哪个线程优先执行，
同一个优先级，随机调度
*/
public class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i ) {
System.out.println("done:"+i);
}
}
}
public class Demo2Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
for (int i = 0; i ) {
System.out.println("maindone:" + i);
}
}
}
maindone:0
done:0
done:1
done:2
done:3
done:4
done:5
done:6
done:7
maindone:1
maindone:2
maindone:3
maindone:4
maindone:5
maindone:6
maindone:7
maindone:8
maindone:9
maindone:10
maindone:11
maindone:12
maindone:13
maindone:14
maindone:15
maindone:16
maindone:17
done:8
done:9
done:10
done:11
done:12
done:13
done:14
done:15
done:16
maindone:18
maindone:19
done:17
done:18
done:19
public class MyThread extends Thread{
@Override
public void run() {
String ThreadName= getName();
System.out.println(ThreadName);
}
}
public class Demo2Test {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
MyThread myThread2 = new MyThread();
myThread2.start();
}
}
/*
Thread-0
Thread-1
*/
public class MyThread extends Thread{
@Override
public void run() {
// String ThreadName= getName();
// System.out.println(ThreadName);
//获取当前运行的线程，引用
Thread ct = Thread.currentThread();
System.out.println(ct);
System.out.println(ct.getName());
}
}
System.out.println(Thread.currentThread().getName());
Thread[Thread-0,5,main]
Thread-0
Thread[Thread-1,5,main]
Thread-1
public class MyThread extends Thread{
public MyThread() {
}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
public class Demo2Test {
public static void main(String[] args) {
MyThread myThread = new MyThread("quan");
myThread.start();
MyThread myThread2 = new MyThread();
myThread2.start();
}
}
/*
quan
Thread-0
*/
public class Demo2Test {
public static void main(String[] args) {
for (int i = 1; i ) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package Thread;
public class RunnableImpl implements Runnable{
@Override
public void run() {
for (int i = 0; i ) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
public class Demo2Test {
public static void main(String[] args) {
RunnableImpl runn = new RunnableImpl();
//传入runnable对象
Thread td = new Thread(runn);
//掉用start方法
td.start();
for (int i = 0; i ) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
/*
main0
Thread-00
main1
Thread-01
Thread-02
Thread-03
*/
public class DemoTest3 {
public static void main(String[] args) {
//匿名内部类，线程父类是Thread
new Thread() {
//重写run方法
@Override
public void run() {
for (int i = 0; i ) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}
}.start();//创建完子类调用start开启线程
//匿名内部类，父类是Runnable接口
//利用接口等于一个实现接口的类---多态
Runnable runn = new Runnable() {
@Override
public void run() {
for (int i = 0; i ) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}
};
Thread th = new Thread(runn);
th.start();
//或则：
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i ) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}
}).start();
//再或者：lambda表达式
new Thread(()->{
for (int i = 0; i ) {
System.out.println(Thread.currentThread().getName() + "---" + i);
}
}).start();
}
}