Thread类
1.new状态(新建)
2.runnable状态(运行)
3.blocked状态(阻塞),
4.time_waiting状态(睡眠),sleep(毫秒值)方法
5.waiting状态(等待),wait(毫秒值)方法自己醒[相当于:sleep(毫秒值)方法],wait()方法等待唤醒
6.terminated状态(死亡)
1.继承Thread类
public class DemoThread extends Thread{
@Override
public void run() {
// 1.继承Thread,重写run()方法,
for (int a = 0; a < 10; a++) {
System.out.println("线程类的a=="+a);
}
}
public static void main(String[] args) {
//子线程
DemoThread demoThread =new DemoThread();// 2.创建子线程
demoThread.start();// 3.开启线程
for (int b = 0; b < 10; b++) {
System.out.println("子b=="+b);
}
//子线程
DemoThread demoThread2 =new DemoThread();// 2.创建子线程
demoThread2.start();// 3.开启线程
for (int c = 0; c < 10; c++) {
System.out.println("子c=="+c);
}
}
}
Thread类长用的方法:
public class DemoThread extends Thread {
@Override
public void run() {
String name = getName();//获取线程名称(主线程:main 新线程:Thread-0/Thread-1/...........)
System.out.println("新线程名称:" + name);
Thread thread = Thread.currentThread();//获取当前线程
String name1 = Thread.currentThread().getName();//获取当前线程的名称
System.out.println("当前执行的线程有:" + thread);
System.out.println("当前线程的名称" + name1);
}
public static void main(String[] args) {
DemoThread demoThread = new DemoThread();
demoThread.start();//新线程
new DemoThread().start();//新线程
new DemoThread().start();//新线程
}
}
输出为:
新线程名称:Thread-0
新线程名称:Thread-1
当前执行的线程有:Thread[Thread-1,5,main]
当前线程的名称Thread-1
当前执行的线程有:Thread[Thread-0,5,main]
当前线程的名称Thread-0
新线程名称:Thread-2
当前执行的线程有:Thread[Thread-2,5,main]
当前线程的名称Thread-2
public class DemoThread extends Thread {
@Override
public void run() {
super.run();
}
public static void main(String[] args) throws InterruptedException {
for (int i = 1; i <= 10; i++) {
System.out.println(i);
Thread.sleep(1000);//线程睡眠1000毫秒执行
}
}
}
2.实现Runnable接口
避免了单继承的局限性.
增强了程序的扩展性.(设置线程任务和开启新线程进行分离)
public class DemoThread implements Runnable{
@Override
public void run() {
//1.实现Runnable接口,重写run()方法:用来设置线程任务
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"---------->"+i);
}
}
public static void main(String[] args) {
DemoThread demoThread = new DemoThread();
Thread t = new Thread(demoThread);//2.Thread类对象中传递实现类对象:开启新的线程
t.start();
}
}
输出为:
Thread-0---------->0
Thread-0---------->1
Thread-0---------->2
Thread-0---------->3
Thread-0---------->4
Thread-0---------->5
Thread-0---------->6
Thread-0---------->7
Thread-0---------->8
Thread-0---------->9
public class DemoThread implements Runnable{
@Override
public void run() {
//1.实现Runnable接口,重写run()方法
}
public static void main(String[] args) {
DemoThread thread1 = new DemoThread();
Thread t = new Thread(thread1);//Thread类对象中传递实现类对象
t.start();
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+"---------->"+i);
}
DemoThread thread2 = new DemoThread();
new Thread(thread2).start();
for (int i = 0; i < 5; i++) {
System.out.println("第二个新线程");
}
}
}
输出为:
main---------->0
main---------->1
main---------->2
main---------->3
main---------->4
第二个新线程
第二个新线程
第二个新线程
第二个新线程
第二个新线程
匿名(没有名字)内部类(其他类的内部)创建多线程
//new Thread方式
new Thread(){
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("匿名内部类创建多线程---new Thread");
}
}
}.start();
//new Runnable()方式
Runnable runnable = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println("匿名内部类创建多线程---new Runnable()");
}
}
};
new Thread(runnable).start();//开启线程
输出:
匿名内部类创建多线程---new Thread
匿名内部类创建多线程---new Thread
匿名内部类创建多线程---new Thread
匿名内部类创建多线程---new Runnable()
匿名内部类创建多线程---new Runnable()
匿名内部类创建多线程---new Runnable()
等待和唤醒
public class DemoThread {
public static void main(String[] args) {
Object obj = new Object();
new Thread() {
@Override
public void run() {
while (true) {
System.out.println("第一个线程执行");
synchronized (obj) {
try {
obj.wait();//第一个线程执行无线睡眠,等待唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("唤醒之后执行的代码");
System.out.println("________________________________________");
}
}
}
}.start();
new Thread() {
@Override
public void run() {
while (true) {
try {
Thread.sleep(1000);//睡眠1秒后执行第二个线程
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj) {
//注意:锁对象不要包裹住睡眠
System.out.println("1秒后执行第二个线程");
obj.notify();//唤醒线程,如果有多个线程,随机唤醒一个
//notify()和wait()需要使用同一个锁对象
//bj.notifyAll();//唤醒所有线程
}
}
}
}.start();
}
}
输出为:
第一个线程执行
1秒后执行第二个线程
唤醒之后执行的代码
________________________________________
第一个线程执行
1秒后执行第二个线程
唤醒之后执行的代码
________________________________________
线程池(一直开启,使用完线程后自动归还给线程池)
线程池原理:
线程池其实就是一个集合(ArrayList,LinkedList,Hashset,HashMap),当程序启动的时候,创建多个线程,保持到集合中,当使用线程的时候,就从集合中取出线程使用.
使用线程:
Thread t = list.remove(0)//返回的是被移除的线程,线程只能被一个任务使用
Thread t = linked.removeFirst() 等等
归还线程到线程池:
list.add(t)
linked.addLast(t)
JDK1.5之后提供了线程池的方法.
Executor:线程池生产类
1.生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口,重写run()方法
3.开启线程执行run()方法
public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool(2);//1.生产一个指定线程数量的线程池
es.submit(new TreadsPoolDemo());//3.开启线程执行run()方法
es.submit(new TreadsPoolDemo());//3.开启线程执行run()方法
es.submit(new TreadsPoolDemo());//3.开启线程执行run()方法
}
一个类实现Runnable接口,重写run()方法
public class TreadsPoolDemo implements Runnable{
@Override
public void run() {
//2.创建类,实现Runnable接口,重写run()方法
System.out.println("获取线程名称:"+Thread.currentThread().getName());
}
}
输出为:
获取线程名称:pool-1-thread-2
获取线程名称:pool-1-thread-2
获取线程名称:pool-1-thread-1