java 非法线程_java-多线程

并发性是一系列性能技术，专注于减少等待

如果你的程序中的一个任务由于程序控制之外的某些条件(通常是I/O)而无法继续，我们会说任务或线程阻塞

进程和线程

线程的调度:

分时调用

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

抢占式调度

优先让优先级较高的线程使用CPU,如果线程的优先级相同，那么会随机选择一个(线程随机性)，

java使用的为抢占式调度

主线程

/*主程序:执行主方法的线程

单线程程序:java程序中只有一个线程

执行从main方法开始,从上到下一次执行*/

单线程程序

public classDemo1Test {public static voidmain(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 extendsThread{

@Overridepublic voidrun() {for (int i = 0; i < 20; i++) {

System.out.println("done:"+i);

}

}

}

实例化子类并调用start方法：

public classDemo2Test {public static voidmain(String[] args) {

MyThread myThread= newMyThread();

myThread.start();for (int i = 0; i < 20; i++) {

System.out.println("maindone:" +i);

}

}

}

结果

maindone:0done:0done:1done:2done:3done:4done:5done:6done:7maindone:1maindone:2maindone:3maindone:4maindone:5maindone:6maindone:7maindone:8maindone:9maindone:10maindone:11maindone:12maindone:13maindone:14maindone:15maindone:16maindone:17done:8done:9done:10done:11done:12done:13done:14done:15done:16maindone:18maindone:19done:17done:18done:19

View Code

分析，

简单而言：

Thread累

获取线程名字1111

创建Thread子累：

public class MyThread extendsThread{

@Overridepublic voidrun() {

String ThreadName=getName();

System.out.println(ThreadName);

}

}

实例化：

public classDemo2Test {public static voidmain(String[] args) {

MyThread myThread= newMyThread();

myThread.start();

MyThread myThread2= newMyThread();

myThread2.start();

}

}/*Thread-0

Thread-1*/

获取线程名字2222

子类修改

public class MyThread extendsThread{

@Overridepublic voidrun() {//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-0Thread[Thread-1,5,main]

Thread-1

设置线程名称 setName

子类:

public class MyThread extendsThread{publicMyThread() {

}publicMyThread(String name) {super(name);

}

@Overridepublic voidrun() {

System.out.println(Thread.currentThread().getName());

}

}

public classDemo2Test {public static voidmain(String[] args) {

MyThread myThread= new MyThread("quan");

myThread.start();

MyThread myThread2= newMyThread();

myThread2.start();

}

}/*quan

Thread-0*/

线程睡眠方法：sleep

静态方法，直接调用

public classDemo2Test {public static voidmain(String[] args) {for (int i = 1; i < 60; i++) {

System.out.println(i);try{

Thread.sleep(1000);

}catch(InterruptedException e) {

e.printStackTrace();

}

}

}

}

创建线程的第二种方式

实现接口累，必须重载

packageThread;public class RunnableImpl implementsRunnable{

@Overridepublic voidrun() {for (int i = 0; i < 20; i++) {

System.out.println(Thread.currentThread().getName()+i);

}

}

}

public classDemo2Test {public static voidmain(String[] args) {

RunnableImpl runn= newRunnableImpl();//传入runnable对象

Thread td = newThread(runn);//掉用start方法

td.start();for (int i = 0; i < 20; i++) {

System.out.println(Thread.currentThread().getName()+i);

}

}

}/*main0

Thread-00

main1

Thread-01

Thread-02

Thread-03*/

继承Thread和实现Runnable接口的区别

我们可以按照不同的需求去将实现累修改，传入不同的实现类给Thread的构造方法就行

建议使用Runnable

使用匿名内部类方式实现线程的创建

public classDemoTest3 {public static voidmain(String[] args) {//匿名内部类，线程父类是Thread

newThread() {//重写run方法

@Overridepublic voidrun() {for (int i = 0; i < 20; i++) {

System.out.println(Thread.currentThread().getName()+ "---" +i);

}

}

}.start();//创建完子类调用start开启线程//匿名内部类，父类是Runnable接口//利用接口等于一个实现接口的类---多态

Runnable runn = newRunnable() {

@Overridepublic voidrun() {for (int i = 0; i < 20; i++) {

System.out.println(Thread.currentThread().getName()+ "---" +i);

}

}

};

Thread th= newThread(runn);

th.start();//或则：

new Thread(newRunnable() {

@Overridepublic voidrun() {for (int i = 0; i < 20; i++) {

System.out.println(Thread.currentThread().getName()+ "---" +i);

}

}

}).start();//再或者：lambda表达式

new Thread(()->{for (int i = 0; i < 20; i++) {

System.out.println(Thread.currentThread().getName()+ "---" +i);

}

}).start();

}

}