Java线程练习1

启动多线程：
使用继承Threadpackage 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