华清远见学习心得第二弹

 

 

文章目录

• 前言
• 创建线程的几种方式
  • 1.继承Thread类
  • 2.实现Runnable接口
  • 3.实现Callable接口
• 总结

• 线程常见方法

 

 

---

前言

今天给大家分享的是Java中线程的创建方式及线程常见方法，我们以前经常听到“线程”、“进程”，那么什么是线程呢？它和进程的区别又是什么呢？线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。而进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。接下来我们来看看线程的创建方式都有哪些吧！

                                              

---

 

 

 

一、线程的创建方式

方式一：继承Thread类

创建线程：创建一个自定义类继承Thread类，重写run方法

开启线程：创建该类对象，并调用start()方法，等待cpu的工作

public class MyThread extends Thread {
     @Override
      public void run() {
        for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
 
    }
}


public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		  MyThread mt = new MyThread();   //线程创建和启动方式一：继承Thread类
		  mt.start();
	}
}

方式二：实现Runnable接口

创建线程：创建一个类实现Runnable接口，实现run方法

开启线程：创建该类对象，再创建Thread类对象，并将该类对象通过构造函数传入Thread类对象。使用Thread类对象调用start方法。

public class MyThread2 implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}		
	}

}

public class Test {

	public static void main(String[] args) {
        MyThread2 mt2 = new MyThread2();  
	    Thread thread = new Thread(mt2);
	    thread.start();

方式三：使用Callable和FutureTask

• 创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
• 使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
• 使用FutureTask对象作为Thread对象的目标创建并启动线程（因为FutureTask实现了Runnable接口）
• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

public class Test {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// TODO Auto-generated method stub
       MyCallable myCallable = new MyCallable();
       FutureTask<String> ft = new FutureTask<String>(myCallable);
       Thread thread = new Thread(ft);
       thread.start();
       System.out.println(ft.get());
	}

}

public class MyCallable implements Callable<String>{

	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub		
		for (int i = 0; i <=100; i++) {
			System.out.println("加载进度："+i+"%");
			Thread.sleep(100);
		}
		return "加载完成，正在进入游戏...";
	}

}

 

总结：

方式	优点	缺点
继承Thread类	编程比较简单，可以直接使用Thread类中的方法	扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口	扩展性强，实现该接口的同时还可以继承其他的类	编程相对复杂，不能返回线程执行的结果
使用Callable和FutureTask	扩展性强，实现该接口的同时还可以继承其他的类，可以得到线程的执行结果	编程相对复杂

 

二、线程常见方法

 

（1）Thread.currentThread()

          获得当前线程

（2）Thread.currentThread().getName()

          获得当前线程的名称

（3）Thread.currentThread().setName(’’)

          设置当前线程的名称

（4）sleep()

在指定时间内让当前执行的线程暂停执行一段时间，让其他线程有机会继续执行，但不会释放对象锁，也就是说如果有synchronized同步块，其他线程仍然不能访问共享数据，不推荐使用。sleep() 使当前线程进入阻塞状态，在指定时间不会执行，因此sleep()方法常用来暂停线程的执行，当sleep()结束后，然后转入到 Runnable(就绪状态)，这样才能够得到执行的机会。

（5）yield()

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

（6）join()  （插队）

join()是Thread类的一个方法，根据jdk文档的定义，join()方法的作用，是等待这个线程结束，即当前线程等待另一个调用join()方法的线程执行结束后在往下执行。通常用于在main主线程内，等待其它调用join()方法的线程执行结束再继续执行main主线程。

（7）wait()、notify和notifyAll()

在synchronized 代码块执行，说明当前线程一定是获取了锁的。当线程执行wait()方法的时候，会释放当前的锁，然后让出CPU，进入等待状态。只有当 notify/notifyAll() 被执行时候，才会唤醒一个或多个正处于等待状态的线程，然后继续往下执行，直到执行完synchronized 代码块的代码或是中途遇到wait() ，再次释放锁。也就是说，notify/notifyAll() 的执行只是唤醒沉睡的线程，而不会立即释放锁，锁的释放要看代码块的具体执行情况。所以在编程中，尽量在使用了notify/notifyAll() 后立即退出临界区，以唤醒其他线程让其获得锁。

 

 

今天的分享就到这里啦，感谢观看嘿嘿~~

 

 

 

 

 

 

---