1、继承Thread类
public class ThreadTest01 {
public static void main(String[] args) {
MyThread myThread1 = new MyThread("周星驰");
MyThread myThread2 = new MyThread("成龙");
myThread1.start();
myThread2.start();
}
}
1.1、继承Thread类
1.2、复写run方法
1.3、new 新的类对象
1.4、调用新类的start方法
class MyThread extends Thread{
private String name;
public MyThread(String name){
this.name = name;
}
public void run(){
for(int i=0;i<100;i++){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>"+name+"--->"+i);
}
}
}
2、实现Runnable接口（使用静态代理的方式实现的）
public class ThreadTest02 {
public static void main(String[] args) {
MyThread02 myThread1 = new MyThread02("周星驰");
MyThread02 myThread2 = new MyThread02("成龙");
Thread thread1 = new Thread(myThread1);
Thread thread2 = new Thread(myThread2);
thread1.start();
thread2.start();
}
}
2.1、实现Runnable接口
2.2、复写run方法
2.3、new 新的类对象
2.4、new一个Thread对象（传入上面的对象）
2.5、Thread对象调用start方法启动线程
class MyThread02 implements Runnable{
private String name;
public MyThread02(String name){
this.name = name;
}
public void run() {
for(int i=0;i<100;i++){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>"+name+"--->"+i);
}
}
}
3、实现Callable接口
public class ThreadTest03 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService ser = Executors.newFixedThreadPool(2);
MyThread03 myThread1 = new MyThread03("周星驰");
MyThread03 myThread2 = new MyThread03("成龙");
Future<String> future1 =ser.submit(myThread1);
Future<String> future2 =ser.submit(myThread2);
Thread.sleep(5000);
myThread1.setFlag(false);
myThread2.setFlag(false);
String result1 =future1.get();
String result2 =future2.get();
System.out.println("-----------------------");
System.out.println(result1);
System.out.println(result2);
ser.shutdownNow();
}
}
3.1、实现Callable接口
3.2、复写call方法（返回值类型需与Callable接口的泛型一致）
3.3、ExecutorService ser = Executors.newFixedThreadPool(2)创建一个线程池，用于启动线程
3.4、new一个线程对象
3.5、定义一个Future类型的参数接受线程池提交的线程对象后的“未来值”
3.6、通过Future的get()方法，获取到线程返回的值，该方法会阻塞线程，即调用该方法后，主线程会等到新启的线程
结束拿到结果后，才会执行后面的代码
3.7、调用shutdownNow()方法，关闭线程池（否则主线程不会结束）
class MyThread03 implements Callable<String>{
private String name;
private boolean flag =true;
public MyThread03(String name){
this.name = name;
}
public String call() throws Exception {
int i = 0;
while(flag){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
i++;
System.out.println("------>"+name+"--->"+i);
}
return name;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
4、三种特殊写法
public class ThreadTest04 {
public static void main(String[] args) {
new Thread(){
private String name ="周星驰";
public void run(){
for(int i=0;i<100;i++){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>"+name+"--->"+i);
}
}
}.start();
new Thread(new Runnable(){
private String name ="成龙";
public void run() {
for(int i=0;i<100;i++){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>"+name+"--->"+i);
}
}
}).start();
new Thread(new Thread(){
private String name ="李连杰";
public void run() {
for(int i=0;i<100;i++){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>"+name+"--->"+i);
}
}
}).start();
}
}
5、Join()方法，合并线程，是把被调用的线程合并到主线程中，并行变串行，主线程进入等待，直到被合并进来的线程执行完后，主线程才继续进行
public class ThreadTest05 extends Thread{
private String name;
public ThreadTest05(String name){
this.name = name;
}
public static void main(String[] args) {
ThreadTest05 threadTest05 = new ThreadTest05("成龙");
Thread thread = new Thread(threadTest05);
thread.start();
for(int i=0;i<100;i++){
if(i==50){try {thread.join();} catch (InterruptedException e) {e.printStackTrace();}}
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>main--->"+i);
}
}
public void run(){
for(int i=0;i<100;i++){
try {Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println("------>"+name+"--->"+i);
}
}
}
此程序先是两线程一起跑，等到主线程I==50时，主线程停下，等待子线程thread执行完，主线程才继续执行
6、yield()方法，暂停线程（把自己的CPU时间片让出），直到CPU再分给时间片才会继续运行，此方法为static方法，Thread.yield(),写在哪个线程，哪个线程就暂停，与sleep相似
public class ThreadTest06 extends Thread{
private String name;
public ThreadTest06(String name){
this.name = name;
}
public static void main(String[] args) {
ThreadTest06 threadTest06 = new ThreadTest06("成龙");
Thread thread = new Thread(threadTest06);
thread.start();
for(int i=1;i<100;i++){
if(i%20==0){Thread.yield();}
System.out.println("------>main--->"+i);
}
}
public void run(){
for(int i=0;i<100;i++){
System.out.println("------>"+name+"--->"+i);
}
}
}
7、Sleep()方法，让线程睡眠，static方法，太常见，例子略
Thread.currentThread()获取当前线程static方法，thread.setName("name")给线程设置名称，thread.getName()获取线程名称
thread.isAlive()判断线程是否是存活状态
网友评论