java多线程

关于内存

每个线程会有自己的线程栈，即，变量不能共享，只能传值拷贝

每个线程new出的对象全都保存在堆中，全部共享

线程的生命周期

线程具有5种状态，即新建，就绪，运行，阻塞，死亡。

新建，当new出来一个线程以后，jvm为其分配内存空间，并初始化成员变量的值

就绪，当线程调用了strat()方法的时候，线程就绪，会为其创建方法调用栈和程序计数器。

方法调用栈 即，记录方法调用的次数

程序计数器 存放下一条单元指令的地方

运行；就绪状态获得cpu，开始执行run()方法

阻塞：例如进入I/O操作

新建，就绪

使用new关键字创建一个线程以后，该线程处于新建状态，和其他java线程一样，仅仅由java虚拟机为其分配内存，初始化变量成员的值。

运行和阻塞

线程调度

桌面和服务器使用抢占式调度策略，小型设备使用协作式调度策略，

线程阻塞

线程使用sleep()方法主动放弃所占用的处理器资源。

线程调用阻塞式I/O方法，方法被返回前，阻塞

线程等待通知

线程调用suspend()挂起

解除阻塞

依依对应即可

线程优先级

普通5，低1，高10

默认是5

关于start和run

start创建一个线程，由于是时间片运行的，所以需要run方法进行运行。

总结

start创建线程，run方法运行线程。

创建线程

使用Thread继承类实现创建线程

文档 https://docs.oracle.com/javase/8/docs/api/

该类必须重写run方法。为新线程的入口点。

必须调用start()方法才能运行。

本质上是Runnable接口的一种实现

package demo2;

public class test {

public static void main(String[] args) {

// 创建一个线程

ThreadDemo run1 = new ThreadDemo();

run1.start();// 启动线程

// 在运行线程以后，会不定时的jvm调用run方法，进行运行

}

}

package demo2;

public class ThreadDemo extends Thread{

public ThreadDemo() {

System.out.println("hello world");

}

public void run() {

System.out.println("线程进入");

for(int i = 0; i > 10; i++) {

System.out.println("输出内容");

}

System.out.println("线程执行完毕");

}

}

事实上父类的start方法也可以重写

package demo2;
public class ThreadDemo extends Thread{
	public ThreadDemo() {
		System.out.println("hello world");
	}
	
	public void run() {
		System.out.println("线程进入");
		for(int i = 0; i > 10; i++) {
			System.out.println("输出内容");
		}
		System.out.println("线程执行完毕");
	}
	
	public void start() {
		System.out.println("启动线程");
		this.run();
	}
}

然后测试类

package demo2;
public class test {
	public static void main(String[] args) {
		// 创建一个线程
		ThreadDemo run1 = new ThreadDemo();
		run1.start();// 启动线程
	}
}

Thread方法

public final void setDaemon(boolean on)

用于标记守护线程和用户线程

用户线程，平常创建的普通线程

守护线程，服务于用户线程，不需要上层调用，例如gc垃圾回收为一个明显的守护线程，mysql中也有执行定时任务的线程。

中断线程

它表示一个线程被中断，会抛出错误。

使用Runnable接口

文档https://docs.oracle.com/javase/8/docs/api/

属于java.lang包内的，为自动默认加载的

该接口具有一个run方法，run方法为程序的入口

必须通过Thread类的构造方法实现启动线程

package demo2;
public class test {
	public static void main(String[] args) {
		// 创建一个线程
		demoRunnable r1 = new demoRunnable();
		// 使用Thread类的构造方法传入线程，并起名，然后运行
		new Thread(r1, "name").start();// 创建完成线程以后，调用start启动线程
	}
}
package demo2;
public class demoRunnable implements Runnable{
	private int i;
	// 下方的为运行的线程
	@Override
	public void run() {
		for(int i = 0; i < 100; i++) {
			System.out.println("运行线程 " + i);
		}
	}
}

通过Callable和Future来创建线程

使用Callable创建接口的实现类

接口源码如下

@FunctionalInterface
public interface Callable<V> {
 V call() throws Exception;
}

实现了一个泛型，该并且返回该类型，需要实现call方法。使用包装对象

关于包装类型，即，将不是对象的内容包装成为对象，为包装类型，实现了对象的类型，为一个类

先实现Callable接口，其中的call类为程序的子线程的执行体

package demo2;
import java.util.concurrent.Callable;
public class CallableDemo implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		System.out.println("开始运行一个线程");
		for(int i = 1, i < 10; i++) {
			System.out.println("运行中");
		}
		// 阻塞该线程
		Thread.sleep(200);
		return 1;	// 返回线程的值
	}
}

接着创建Future对象，将用于启动子线程

package demo2;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class test {
	public static void main(String[] args) {
		// 先创建实例
		CallableDemo ctt = new CallableDemo();
		FutureTask<Integer> ft = new FutureTask<>(ctt);	// 该方法为了获取返回值而设定	
		new Thread(ft, "返回结果的值").start();
		try {
			System.out.println(ft.get());
		} catch (InterruptedException | ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
package demo2;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class CallableDemo implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		System.out.println("开始运行一个线程");
		for(int i = 1; i < 10; i++) {
			System.out.println("运行中");
		}
		return 1;	// 返回线程的值
	}
}