Java是第一个在语言级提供了对多线程程序设计支持的语言。语言级支持是啥意思呢，就是抛开操作系统，只使用Java内置的语句就能实现多线程。一般来讲，多线程会依赖操作系统，我们要高用与系统相关的API才能创建多个线程，如在Windows中的CreateThread()函数。但JAVA就不用了。JAVA运行时系统实现了一个用于调用线程执行的线程调度器，用来决定在某一时刻哪个线程在CPU上运行。
在java技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的CPU时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。线程调度器支持不同优先级线程的抢先方式，但其本身不支持相同优先级线程的时间片轮换。若要想让其支持，则必须将运行时系统运行在支持时间片轮换操作系统上。
1、Thread类和Runnable接口
在Java中实现多线程可以有2种方式，一个是让类继承Thread类，另一个是实现Runnable接口。由于Java不允许多继承，所以当我们让自定义的类继承了Thread类后就不能再继承其它类了，这样会降低日后程序的可扩展性。所以一般我们都是采用实现Runnable接口的方法让一个类具有可执行的特性。
Runnable接口只有一个方法run()，该线程启动时，JVM就会调用run()方法以执行该线程。线程类创建后，必须调用start()方法才能启动线程。如：
package cls;
public class ThreadDemo
{
public static void main(String[] args)
{
//创建线程类对象并实现 Runnable接口
Thread th1 = new Thread(new Runnable()
{
// 实现Runnable中的run()方法
public void run()
{
while(true)
System.out.println("Thread1 is running !");
}
});
Thread th2 = new Thread(new Runnable()
{
public void run()
{
while(true)
System.out.println("Thread2 is running !");
}
});
// 调用start()方法启动线程
th1.start();
th2.start();
}
}
2、Daemon线程
一个Daemon线程指的是一个在后台执行服务的线程。在执行上例代码时，我们发现，当主线程(main函数)执行完th2.start()这一行的时候，主线程的代码就已经全部执行完，所以主线程退出了。但我们看到自己创建的th1和th2两个线程仍然在不停地执行，并没有退出。如果我们想让创建的线程在主函数退出后一同退出，那么就应当将我们创建的线程设置为daemon.Daemon线程当在所有的非Daemon线程都结束后自动退出。
让我们修改一下上例：
package cls;运行后可以看到，200ms后主线程退出，相应的th1和th2也退出了。
public class ThreadDemo
{
public static void main(String[] args)
{
//创建线程类对象并实现 Runnable接口
Thread th1 = new Thread(new Runnable()
{
// 实现Runnable中的run()方法
public void run()
{
while(true)
System.out.println("Thread1 is running !");
}
});
Thread th2 = new Thread(new Runnable()
{
public void run()
{
while(true)
System.out.println("Thread2 is running !");
}
});
// 设置成daemon线程
th1.setDaemon(true);
th2.setDaemon(true);
// 调用start()方法启动线程
th1.start();
th2.start();
// 主函数睡眠一小会
try
{
Thread.currentThread().sleep(200);
}
catch(Exception e)
{
System.out.println(e.toString());
}
}
}
3、线程同步
假设对象A有两个属性a和b,另有一个对象B有属性a和b,并且我们要用对象B来更新对象A。当这种更新操作完成后（对象A的a,b属性值变成了对象B的a,b属性值），则称A与B同步。
如果对象B在更新对象A时（还没更新完），又来了个对象C，对象C抢在B之前更新了A，则称A与B不同步。
讨论线程就不得不考虑线程同步的问题。当多个线程共享同一个数据时，容易造成数据的不同步。而这种不同步引发的错误往往难以修正，常常是程序在执行了几千次、几万次甚至是几年才会出现。因此线程同步就显得尤为重要。
下面写一个模拟火车站卖票的例子，故意使得线程不同步，看看会发生什么问题：
package cls;
public class ThreadSynchronized
{
public static void main(String[] args)
{
Ticket tk = new Ticket();
Thread th1 = new Thread(new Sold(tk));
Thread th2 = new Thread(new Sold(tk));
th1.start();
th2.start();
}
}
class Ticket
{
int amount = 100; // 有100张票
// 卖出一张票，总票数减1，返回被卖出的票号
public int sold()
{
return amount--;
}
// 返回当前剩余票数
public int getAmount()
{
return amount;
}
}
// 售票线程
class Sold implements Runnable
{
private Ticket tk;
public Sold1(Ticket tk)
{
this.tk = tk;
}
public void run()
{
while(tk.getAmount() > 0) // 还有余票
{
try
{
Thread.currentThread().sleep(10); // 睡眠一小会
}
catch(Exception e)
{
System.out.println(e.toString());
}
System.out.println("Thread1 sold " + tk.sold());
}
}
}
执行：
我们发现，Thread1这个线程居然卖出了0这张不存在的票。售票线程在卖票前已经做了
tk.getAmount() > 0的判断了，为什么还会卖出0这张票呢？
我们来分析下程序执行的过程：
当还剩下1这张票时，Thread1用getAmout()判断出票数大于0，则进入while循环进行售票。在还没有卖之前遇到了sleep()，于是Thread1会放弃执行机会，进入阻塞状态；这时轮到Thread2执行了，由于Thead1还没有把1卖出，因此Thread2用getAmout()的结果仍然大于0，所以就把1这张票卖出去了。这时候Thread1睡醒了，则继续从sleep()这行开始执行，而这时候票数已经变成了0，那么Thead1自然就会卖出0这张票了。
为了避免此类情况的发生，我们可以使用synchronized关键字来进行线程的同步。
synchronized关键字可以用在方法上，也可以用在语句块中。我们可以形象地把synchronized想象成一把锁。当程序执行到synchronized语句块（以后称为同步块）时，会将这个同步块的代码“上锁”，这时如果我们调用了sleep()方法或者恰好CPU分配的时间片用光了，另一个线程如果也要执行这段代码时，由于先前的线程已经对这个同步块进行了“上锁”，因此这个线程就不能执行同步块中的代码，只能等待，直到它的时间片也用完为止。这时前一个线程又得到了执行的机会，执行完代码块，它会将这个代码块“解锁”，这样别的线程才可以执行这个代码块。也就是说，一个同步块在一个时间段内只能被一个特定的线程执行，在这个线程没有执行完代码块的语句之前，其它线程是没有办法再执行这个块中的代码的。Java是通过请求一个对象的监视器实现这种功能的。一个对象只有一个监视器，当一个线程请求到后，另一个线程在这个线程归还（执行完同步块）监视器之前是无法请求到该对象的监视器的。
现在我们来改写上面的例子：
package cls;
class ThreadSynchronized
{
public static void main(String[] args)
{
Ticket tk = new Ticket();
Sold sd = new Sold(tk);
Thread th1 = new Thread(sd);
Thread th2 = new Thread(sd);
th1.start();
th2.start();
}
}
class Ticket
{
int amount = 100; // 有100张票
// 卖出一张票，总票数减1，返回被卖出的票号
public int sold()
{
return amount--;
}
// 返回当前剩余票数
public int getAmount()
{
return amount;
}
}
// 售票线程
class Sold implements Runnable
{
private Ticket tk;
public Sold(Ticket tk)
{
this.tk = tk;
}
public void run()
{
while(true)
{
// 同步语句块
synchronized(this)//请求 this对象的监视器
{
if(tk.getAmount() > 0)
{
try
{
Thread.currentThread().sleep(1); // 睡眠一小会
}
catch(Exception e)
{
System.out.println(e.toString());
}
System.out.println(Thread.currentThread().getName() + " sold " + tk.sold());
}
}
}
}
}
可以看到，问题就解决了。