java：编写10个线程，第一个线程从1加到10，第二个线程从11加到20……第十个线程从91加到100， 最后再,10个线程结果相加

在生活中，人体可以同时进行各项生命活动。例如，人体可以同时进行呼吸、血液循环等等…
当我们在编写程序时，这些行为我们可以抽象为并发，而将并发完成的每一件事称为线程。

线程创建的两种传统方式
方式一：继承Thread类
1.创建Thread类的子类
2.重写Thread类的run（）方法，将当前线程要执行的操作声明在run（）方法内！
3.实例化Thread类的子类
4通过Thread类的子类对对象调用start（）方法，来启动线程

方式二：实现Runnable接口
1.创建实现类来实现Runnable接口
2.实现接口中的抽象方法run（），将当前线程要执行的操作声明在run（）方法体内
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start（），启动线程

例题：编写10个线程，第一个线程从1加到10，第二个线程从11加到20……第十个线程从91加到100， 最后再将10个线程结果相加。

方式一实现：
public class Test {

public static void main(String[] args) throws InterruptedException {


	for(int i = 0; i< 10;i++)
	{
		Add add = new Add(i*10+1,i*10+10);
		add.start();
	}
	Thread.sleep(50);
	System.out.println("总和："+Add.sum);
}

}

class Add extends Thread
{
static Object object = new Object();
static int sum;

private int begin;//首
private int over;//尾

public Add(int begin,int over)
{
	this.begin = begin;
	this.over = over;
}

private int temp;
public void run()
{
	for(int i = begin;i<= over;i++)
	{
		temp += i;
	}
	//同步代码块
	synchronized(object)
	{
		System.out.println(Thread.currentThread().getName()+"----"+temp);
		sum += temp;
	}
}

}

结果展示：

方式二实现
public class Test {
public static void main(String[] args) {
ABCD abcd = new ABCD();
Thread[] all = new Thread[10];
for(int i=0; i<10; i++)
{
all[i] = new Thread(abcd);
all[i].start();
}
try {
for(int i=0; i<10; i++)
{
all[i].join();
}
} catch (InterruptedException e)
{
e.printStackTrace();
}

	System.out.println("总和："+ABCD.getSum());
}

}
class ABCD implements Runnable{
private static Object lock = new Object();
private static int sum = 0;
private static int num=1;

public void run() 
{
	synchronized(lock)
	{
		for(int i = 1;i<= 10;i++,num++)
		{
			sum +=num;
			System.out.println(Thread.currentThread().getName()+"："+num);
		}	
	}
}

public static int getSum()
{
	return sum;
}

}

结果展示：

上述两种方式的比对
相同点：
1、都需要对run（）方法进行重写
2、启动线程都需要调用Thread类的start()方法
比较：
1、类可以实现多个接口，但只能继承一个父类
2、实现的Runna方式适合于资源的共享
结论：
在多线程的条件下，实现Runnable的方式要好于继承Thread的方式

小彩蛋
超级好懂的程序，适合自学的道友
public class Test {

public static int sum=0;
public static Object LOCK=new Object();

class Threadtest extends Thread{

	private int begin;
	private int end;
	
	public void run() 
	{
		synchronized (LOCK) 
		{
			for(int i=begin;i<=end;i++)
			{
				sum+=i;
			}
			System.out.println(Thread.currentThread().getName()+"---:"+sum);
		}
	}
	public Threadtest(int begin, int end) {
		this.begin = begin;
		this.end = end;
	}	
}
public static void main(String[] args)throws InterruptedException {
	Test t11 =new Test();
	Threadtest t1=t11.new Threadtest(1, 10);
	t1.setName("1号");
	Threadtest t2=t11.new Threadtest(11, 20);
	t2.setName("2号");
	Threadtest t3=t11.new Threadtest(21, 30);
	t3.setName("3号");
	Threadtest t4=t11.new Threadtest(31, 40);
	t4.setName("4号");
	Threadtest t5=t11.new Threadtest(41, 50);
	t5.setName("5号");
	Threadtest t6=t11.new Threadtest(51, 60);
	t6.setName("6号");
	Threadtest t7=t11.new Threadtest(61, 70);
	t7.setName("7号");
	Threadtest t8=t11.new Threadtest(71, 80);
	t8.setName("8号");
	Threadtest t9=t11.new Threadtest(81, 90);
	t9.setName("9号");
	Threadtest t10=t11.new Threadtest(91, 100);
	t10.setName("10号");
	
	t1.start();
	t2.start();
	t3.start();
	t4.start();
	t5.start();
	t6.start();
	t7.start();
	t8.start();
	t9.start();
	t10.start();
	
	t1.join();
	t2.join();
	t3.join();
	t4.join();
	t5.join();
	t6.join();
	t7.join();
	t8.join();
	t9.join();
	t10.join();
	System.out.println("总和："+sum);			
}

}
结果展示

线程简易的生命周期图

ps：万物皆对象，你有对象吗？