进程:资源分配的基本单位
线程:资源调度的基本单位
为了进程能进行并发操作
创建进程有两种方法(一般推荐第二种,因为单继承问题)
public class Threadtest extends Thread {
//设置名字
public Threadtest(String name) {
super(name);
}
//重写方法
public void run(){
for(int i = 0;i < 100;i++){
System.out.println(Thread.currentThread().getName() + "-----" + i);
}
}
public static void main(String[] args) {
Threadtest t1 = new Threadtest("线程1");
Threadtest t2 = new Threadtest("线程2");
t1.start();
t2.start();
}
}
public class Runnabletest implements Runnable {
@Override
public void run() {
for(int i = 0;i < 100;i++){
System.out.println(Thread.currentThread().getName() + ":::" + i);
}
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnabletest(),"线程1");
Thread t2 = new Thread(new Runnabletest(),"线程2");
t1.start();
t2.start();
}
}
// 上面两种方法都是线程交替进行
线程1:::0
线程1:::1
线程1:::2
线程1:::3
线程1:::4
线程2:::0
线程1:::5
线程1:::6
线程1:::7
线程1:::8
线程1:::9
线程1:::10
线程2:::1
Thread-Number
,eg: Thread-0
/**
* Allocates a new {@code Thread} object. This constructor has the same
* effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
* {@code (null, null, gname)}, where {@code gname} is a newly generated
* name. Automatically generated names are of the form
* {@code "Thread-"+}<i>n</i>, where <i>n</i> is an integer.
*/
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
/* For autonumbering anonymous threads. */
private static int threadInitNumber;
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
Thread thread = new Thread(() -> {
System.out.println(Thread.currentThread().getName());
});
thread.setName("新线程名");
新线程名
public final void setDaemon(boolean on) {
checkAccess();
if (isAlive()) {
throw new IllegalThreadStateException();
}
daemon = on; //设置守护线程为真
}
/* Whether or not the thread is a daemon thread. */
// private boolean daemon = false;
// MAX_PRIORITY 最大级别10
// MIN_PRIORITY 最小0
// NORM_PRIORITY 普通5
public final void setPriority(int newPriority) {
ThreadGroup g; //线程组
checkAccess();
if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
throw new IllegalArgumentException();
}
if((g = getThreadGroup()) != null) {
if (newPriority > g.getMaxPriority()) {
newPriority = g.getMaxPriority();
}
setPriority0(priority = newPriority); //设置级别,后面遇到native方法不说明了
}
}
public static void main(String[] args) {
Threadtest t1 = new Threadtest("线程1");
Threadtest t2 = new Threadtest("线程2");
//设置优先级
t1.setPriority(10);
t1.start();
t2.start();
}
线程1:::97
线程1:::98
线程1:::99
线程2:::3
线程2:::4
线程2:::5
在前面实例中调用该函数,发现t1线程cpu执行时间片多于t2线程,t1完成了t2还在开头
public class Threadtest extends Thread {
//设置名字
public Threadtest(String name) {
super(name);
}
//重写方法
public void run(){
for(int i=0; i < 100;i++){
System.out.println(Thread.currentThread().getName() + "--" + i);
}
}
public static void main(String[] args) throws InterruptedException {
Threadtest t2 = new Threadtest("线程2");
t2.start();
t2.sleep(10000);
System.out.println("=========");
}
}
线程2--96
线程2--97
线程2--98
线程2--99
//10秒后,main线程睡眠
=======
public class Threadtest extends Thread {
//设置名字
public Threadtest(String name) {
super(name);
}
//重写方法
public void run(){
for(int i=0; i < 100;i++){
System.out.println(Thread.currentThread().getName() + "--" + i);
}
}
public static void main(String[] args) throws InterruptedException {
Threadtest t1 = new Threadtest("线程1");
Threadtest t2 = new Threadtest("线程2");
t2.setPriority(10);
t1.start();
t1.join(); //main线程停下来,等t1执行完才继续往下执行,所以先输入t1,再输出t2
t2.start();
}
}
thread.wait();
thread.notify();
使当前线程从运行状态转为就绪状态,即可能让别的线程执行,也可能自己再次执行
Thread t1 = new Thread(new Runnable(()->{
// 若未发生中断,就正常执行任务
while(!Thread.currentThread.isInterrupted()){
// 正常任务代码……
}
// 中断的处理代码……
doSomething();
}).start();
退出当前线程(或者当run方法结束也是线程结束)
获取当先运行的线程,Thread thread = Thread.currentThread(),属于静态方法