多线程----基础

一. 创建线程类

法一:新建类继承thread类,重写run方法.

法二:实现Runnable接口,重写run方法.

1.例子:

public class _thread extends Thread{
	public _thread(String name) {
		setName(name);
	}

	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			try {
				Thread.sleep(100);
				System.out.println(getName()+"执行步骤"+i);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
	
	public static void main(String[] args) {
		Thread t1=new _thread("线程1");
		Thread t2=new _thread("线程2");
		t1.start();
		t2.start();

	}
}

2.多个线程共享同一资源(代理)

public class qiangpaio implements Runnable {

	int num=50;
	@Override
	public  void run() {
		while(num>0) {
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"抢了第"+num--);
			
		}
	}
	
	public static void main(String[] args) {
		qiangpaio p1=new qiangpaio();      //只建立了一个抢票类
		Thread t1=new Thread(p1,"张三");
		
		Thread t2=new Thread(p1,"李四");
		
		Thread t3=new Thread(p1,"王五");   //让该抢票类加入三个不同的线程
		t1.start();
		t2.start();
		t3.start();
	}

}

二.停止线程

1.自然终止:线程体执行完毕

2.加入falg表示,外部改变flag状态

三.阻塞

1.join() :主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。

public class JoinTest {
    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("小明");
        ThreadJoinTest t2 = new ThreadJoinTest("小东");
        t1.start();
        /**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：
         程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕
         所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会
         */
        t1.join();
        t2.start();
    }

}
class ThreadJoinTest extends Thread{
    public ThreadJoinTest(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=0;i<1000;i++){
            System.out.println(this.getName() + ":" + i);
        }
    }
}

1) join(int x) 表示a线程等待b线程x毫秒; x毫秒之后,由串行执行变成普通的并行执行

2)jion()必须在strat()方法之后调用

2. Thread.yield( )

使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。

Java线程中有一个Thread.yield( )方法，很多人翻译成线程让步。顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，让自己或者其它的线程运行。

打个比方：现在有很多人在排队上厕所，好不容易轮到这个人上厕所了，突然这个人说：“我要和大家来个竞赛，看谁先抢到厕所！”，然后所有的人在同一起跑线冲向厕所，有可能是别人抢到了，也有可能他自己有抢到了。我们还知道线程有个优先级的问题，那么手里有优先权的这些人就一定能抢到厕所的位置吗? 不一定的，他们只是概率上大些，也有可能没特权的抢到了。

package com.yield;
 
public class YieldTest extends Thread {
 
	public YieldTest(String name) {
		super(name);
	}
 
	@Override
	public void run() {
		for (int i = 1; i <= 50; i++) {
			System.out.println("" + this.getName() + "-----" + i);
			// 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
			if (i == 30) {
				this.yield();
			}
		}
	}
 
	public static void main(String[] args) {
		YieldTest yt1 = new YieldTest("张三");
		YieldTest yt2 = new YieldTest("李四");
		yt1.start();
		yt2.start();
	}
}

第一种情况：李四（线程）当执行到30时会CPU时间让掉，这时张三（线程）抢到CPU时间并执行。

第二种情况：李四（线程）当执行到30时会CPU时间让掉，这时李四（线程）抢到CPU时间并执行。

3.Thread.sleep()

四.线程基本信息

-isAlive()

-getPriority()

-setPriority() :三个常量值MAX(10), NORMAL(5), MIN(1)

-getName()

-setName()

-Thread.currentThread()

猜你喜欢