java多线程的放肆有四种
1.继承Thread类，重写run方法。
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类实例对象作为Thread构造器函数的target.
3.通过Callable和FutureTask创建线程。
4.创建线程池创建线程
前面两种可以归一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，
后面两种可以归一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值就是Object，所以返回的结果可以放在Object对象中所以返回的结果可以放在Object对象中。
Thread class Thread1 extends Thread{
public Thread1(){
}
public void run(){
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args){
Thread1 thread1=new Thread1();
thread1.setName("我是自定义的线程1");
thread1.start();
System.out.println(Thread.currentThread().toString());
}
}
//这里输出的话
Thread[main,5,main]
我是自定义的线程
线程实现方式2：通过实现Runnable接口，实现run方法，
接口的实现类的实例作为Thread的target作为参数传入带参数的Thread构造函数，通过调用start()方法启动线程。
public class Thread2{
public static void main(String] args){
System.out.prinyln(Thread.currentTghread().getName());//这是打印出来的信息。
Thread t1=new Thread(new MyThread());
t1.start();
}
}
class MyThread implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"我是通过实现接口的线程方式。");
}
}
线程实现方式3：通过Callable和Future创建线程
a:创建Callable接口的实现类，并实现call方法。
b:创建Callable实现类的实现，使用FutureTask创建线程。
c:使用FutureTask对象作为Thread对象的target创建并启动线程。
d:调用FutureTask对象的get()来获取子线程执行结束返回值。
public class Thread3{
public static void main(String[] args){
Callable<Obejct> oneCallable=new Tickets<Obejct>();
FutureTask<> oneTask=new Future<Object>(oneCallable);
Thread t=new Thread(oneTask);
System.out.println(Thread.currentThread().getName());
t.start();
}
}
下面的例子演示了100个线程同时向一个银行账户中存入1元钱，在没有使用同步机制和使用同步机制情况下的执行情况。
1.在银行账户的存款(deposit)方法上同步(synchronized)关键字。
public class Accout{
private double balance;
public synchronized void deposit(double money){/这里对方法的上锁后，表示同步方法，
其他方法就不能访问同步方法。
double newBalance =balance+money;
try{
Thread.sleep(10);
}catch(Exception e){
e.printStackTrace();
}
balance=newBalance;
}
public double getBalance(){
return balance;
}
}
2.在线程调用存款方法时对银行账户进行同步
public class AddMoneyThread implements Runable{
private Account account;//存入账户
private double money;//存入金额
public AddMoneyThread(Account account,double money){
this.account=account;
this.money=money;
}
@Override
public void run(){
synchronized(account){//这里就是相当于同步代码块。
account.deposit(meney);
}
}
}
synchronized关键字可以将对象或者方法标记为同步，以实现对对象和方法的互斥访问，
可以用synchronized(对象){。。。}定义同步代码块。或者在声明方法时将synchronized作为方法的修饰符。
同步就是阻塞式操作，而一部就是非阻塞式操作。
这里我们说明的一下就是：实现线程继承Thread和实现Runnable的区别：
我们知道的是一类只能是单继承，但是可以是多实现。所以继承Thread类有局限性，
但是实现Runnable很显然，我们可以继承其他类。