Java线程练习1

启动多线程：

使用继承Thread

package testDemo;

public class MyThread extends Thread{
	public String name;
	public MyThread(String name) {
		this.name = name;
	}
	public void run() {
		for(int x=0; x<200; x++) {
			System.out.println(name + ">" + x);
		}
	}
}

测试类：

package testDemo;

public class TestDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread t1 = new MyThread("xiancheng A");
		t1.start();
	}

}

使用实现Runnable接口来实现多线程：它需要在new一个Thread对象，或者在线程类中实现start方法；

package testDemo;

public class MyThread implements Runnable{
	public String name;
	public MyThread(String name) {
		this.name = name;
	}
	public void run() {
		for(int x=0; x<200; x++) {
			System.out.println(name + ">" + x);
		}
	}
}

测试类：

package testDemo;

public class TestDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyThread t1 = new MyThread("xiancheng A");
		new Thread(t1).start();
	}

}

或者这种方式：

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

使用Thread类实现数据共享的概念：

package testDemo;

public class MyThread extends Thread{
	private int ticket = 5; 

	
	public void run() {
		for(int x = 0; x<50; x++) {
			if(this.ticket > 0) {
				System.out.println("卖票，ticket" + this.ticket--);;
			}
		}
	}
}

package testDemo;

public class TestDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//多个线程处理一件事情
		MyThread t1 = new MyThread();
		//下面的线程都是在卖票
		new Thread(t1).start();
		new Thread(t1).start();
	}

}

运行结果：

卖票，ticket4
卖票，ticket3
卖票，ticket5
卖票，ticket2
卖票，ticket1

定义一个线程主体类：

package testDemo;
import java.util.*;
import java.util.concurrent.Callable;
public class MyThread implements Callable<String>{//返回值类型
	private int ticket = 10; 

	
	public String call() throws Exception {
		for(int x = 0; x<50; x++) {
			if(this.ticket > 0) {
				System.out.println("卖票，ticket" + this.ticket--);;
			}
		}
		return "票卖完了";
	}
}

启动多线程：

package testDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// TODO Auto-generated method stub
		
		
		MyThread t1 = new MyThread();//实例化多线程
		MyThread t2 = new MyThread();
		FutureTask<String> task1 = new FutureTask<String>(t1);
		FutureTask<String> task2 = new FutureTask<String>(t2);
		//FutureTask是Runnable接口子类，所以可以使用Thread类的构造来接受task对象
		
		new Thread(task1).start();//启动第一个线程
		new Thread(task2).start();
		//多线程执行3完毕后可以获取内容，依靠的是FutureTask的父接口Future中的get()方法
		System.out.println("A线程的返回结果： " + task1.get());
		System.out.println("B线程的返回结果： " + task2.get());
	}

}

运行结果：

卖票，ticket10
卖票，ticket10
卖票，ticket9
卖票，ticket9
卖票，ticket8
卖票，ticket7
卖票，ticket6
卖票，ticket8
卖票，ticket7
卖票，ticket6
卖票，ticket5
卖票，ticket5
卖票，ticket4
卖票，ticket4
卖票，ticket3
卖票，ticket3
卖票，ticket2
卖票，ticket1
卖票，ticket2
卖票，ticket1
A线程的返回结果： 票卖完了
B线程的返回结果： 票卖完了

多线程常用的操作方法：

package testDemo;
import java.util.*;
import java.util.concurrent.Callable;
public class MyThread implements Runnable{//返回值类型
	public void run(){
		System.out.println(Thread.currentThread().getName());
		}
	}

测试类：

package testDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// TODO Auto-generated method stub
		
		
		MyThread t1 = new MyThread();
		new Thread(t1,"线程A").start();
		new Thread(t1).start();
		new Thread(t1,"线程B").start();
	}

}

运行结果：

线程A
线程B
Thread-0

可以给通过Thread（线程，线程名字）给线程命名，如果没有命名虚拟机会自动给线程添加一个名字；

取得Main方法的线程名字：

package testDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// TODO Auto-generated method stub
		
		
		MyThread t1 = new MyThread();
		t1.run();
		new Thread(t1,"线程A").start();
		
		new Thread(t1).start();
		new Thread(t1,"线程B").start();
	}

}

结果为：

main

观察线程休眠的特点：

package testDemo;
import java.util.*;
import java.util.concurrent.Callable;
public class MyThread implements Runnable{//返回值类型
	public void run(){
		for(int i=0; i<20; i++) {
	
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
			// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+	"、x ="  + i );
			}
		}
		
	}

测试类：

package testDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class TestDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// TODO Auto-generated method stub
		
		
		MyThread t1 = new MyThread();
		new Thread(t1,"线程A").start();
	}

}

运行结果：

线程A、x =0
线程A、x =1
线程A、x =2
线程A、x =3
线程A、x =4
线程A、x =5
线程A、x =6
线程A、x =7
线程A、x =8
线程A、x =9
线程A、x =10
线程A、x =11
线程A、x =12
线程A、x =13
线程A、x =14
线程A、x =15
线程A、x =16
线程A、x =17
线程A、x =18
线程A、x =19