CPU：10核 主频100MHz
1核 主频 3GHz
那么哪一个CPU比较好呢？
CPU核不是越多越好吗？并不一定。主频用于衡量GPU处理速度的快慢，举个例子10头牛运送货物快还是1架飞机运算货物快？显然是1架飞机，因此1核3GHz的CPU较好，当然，在相同主频的情况下，CPU当然是越多越好。
在Java中，JVM虚拟机允许运行多个线程，他通过java.lang.Thread类来实现
Thread类特性：
- 每个线程都是通过某个特定的Thread对象的run()方法来完成操作的，经常把run()方法主体称为线程体；
- 通过该Thread()对象的start()方法来调用这个线程；
构造方法：
- Thread()：创建新的Thread对象；
- Thread(String threadname)：创建线程并为其指定线程实例名；
- Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法；
- Thread(Runnable target,String name)：创建新的Thread对象；
一、创建线程的两种方式：
1.继承Thread类
- 定义子类并继承Thread类
- 子类中重写Thread类中run方法
- 创建Thread子类对象，即创建了线程对象
- 调用线程对象的start方法：启动线程，调用run方法
package testThread;
public class TestThread extends Thread{
public void run() {
System.out.println("多线程运行的代码");
for(int i=0;i<10;i++) {
System.out.println("这是多线程的逻辑代码");
}
}
}
package testThread;
public class Test {
public static void main(String[] args) {
Thread t0 = new TestThread();
//在开启了线程后，线程与main()方法并行运行
t0.start();//启动线程
}
}
2.实现Runnable接口
- 定义子类，实现Runnable接口
- 子类中重写Runnable接口中的run方法
- 通过Thread类含参构造器创建线程对象
- 将Runanable接口的子类对象作为实际参数传递给Thread类的构造方法中
- 调用Thread类的start方法：开启线程、调用Runnable子类接口的run方法
package testThread;
public class TestRunnable implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName()+"开始运行");
for(int i=0;i<10;i++) {
System.out.println("这是多线程的逻辑代码");
}
}
}
package testThread;
public class Test {
public static void main(String[] args) {
Thread t0 = new Thread(new TestRunnable());
t0.start();
Thread t1 = new Thread(new TestRunnable(),"线程t1");
t1.start();
}
}
对于这种方式创建线程，可以给每个线程进行命名，否则默认为Thread-num。
利用实现方式：避免了单继承的局限性、多个线程可以共享同一个接口实现类对象，非常适合多个相同线程来处理同一份资源。
二、Thread类的相关方法
（1）基础方法
void start()：启动线程
run()：线程在被调度时执行的操作名称
String getName()：返回线程的名称
void setName(String name)：设置线程的名称
static currentThread()：返回当前线程
（2）优先级方法
- 数字越大，优先级越高：MAX_PRIORITY(10)、MIN_PRIORITY(1)、NORM_PRIORITY(5)
getPriority()：获得优先级
setPriority(int newPriority)：设置优先级
线程创建时继承父线程的优先级
（3）其它方法
static void yield()：线程让步
- 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程；
- 若队列中没有同优先级的线程，忽略此方法；
join()：当某个程序执行流中调用其它线程的join()方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完毕为止。
- 低优先级的线程也可以获得执行
static void sleep(long millis)：指定时间，毫秒
- 令当前活动线程在指定时间段内放弃对CPU控制，使其它线程有机会被执行，时间到后排队；
- 抛出InterruptedException异常
stop()：强制线程生命周期结束
boolean isAlive()：判断线程是否还活着
三、线程的生命周期
JDK中用Thread.State来表示线程的状态，包括：
新建：声明并实例化之后；
就绪：执行start之后；
运行：得到cpu的使用权，run()方法开始运行；
阻塞：run()方法停止执行，处于等待状态；
死亡：线程完成了全部工作或被提前终止；
四、线程的同步
问题：假设账户上有4000，现在有两个线程，分别各取2000，由于这两个线程是并行的，因此都可能取成功，此时账户上就是-1000了，这显然是不合法的。因此，要引入线程的同步，所谓同步，并不是指同时运行，而是指协同步伐，也就是线程按先后顺序依次执行，这样当取出2000后，账户剩余1000，再进行取2000就不会成功了。
package testThread;
public class Test2 {
public static void main(String[] args) {
Account account = new Account();
User u_weChat = new User(account,);
User u_zhifubao = new User(account,);
Thread wechat = new Thread(u_weChat,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
wechat.start();
zhifubao.start();
}
}
class Account{
public static int money = ;
public void get(int m) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
}
class User implements Runnable{
Account account;
int money;
public User(Account account,int money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
// TODO Auto-generated method stub
account.get();
}
}
输出：
正在运行：微信
正在运行：支付宝
微信操作-账户原有金额:3000
支付宝操作-账户原有金额:3000
支付宝操作-取款金额:2000
支付宝操作-取款后的余额:1000
微信操作-取款金额:2000
微信操作-取款后的余额:-1000
此时，正如以上我们所说的，取款不合法了，那么如何解决呢？可以给方法加上同步锁。但是，需要注意的是：
package testThread;
public class Test2 {
public static void main(String[] args) {
Account account = new Account();
Account account1 = new Account();
//意思是这里创建了不同的Account对象，获得的锁是不同对象的锁
User u_weChat = new User(account,);
User u_zhifubao = new User(account1,);
Thread wechat = new Thread(u_weChat,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
wechat.start();
zhifubao.start();
}
}
class Account{
public static int money = ;
//在普通方法上加synchronized，锁的是整个对象，而不是某一个方法
//不同的对象就是不同的锁
public synchronized void wGet(int m) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
public synchronized void zGet(int m) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
}
class User implements Runnable{
Account account;
int money;
public User(Account account,int money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
// TODO Auto-generated method stub
if(Thread.currentThread().getName().equals("微信")) {
account.wGet(money);
}else {
account.zGet(money);
}
}
}
输出：
正在运行：微信
正在运行：支付宝
微信操作-账户原有金额:3000
微信操作-取款金额:2000
支付宝操作-账户原有金额:3000
微信操作-取款后的余额:1000
支付宝操作-取款金额:2000
支付宝操作-取款后的余额:-1000
因为此时不同对象获得的是不同的锁，所以这种方式并不行，那么如何进行改动呢？只需要使用同一个对象即可，即：
Account account = new Account();
User u_weChat = new User(account,);
User u_zhifubao = new User(account,);
此时输出：
正在运行：微信
微信操作-账户原有金额:3000
微信操作-取款金额:2000
微信操作-取款后的余额:1000
正在运行：支付宝
支付宝操作-账户金额不足:1000
同时，还可以进一步简化：
public synchronized void get(int m) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
在最后调用时，只需要在run()方法中调用account.get()即可，不用将两个方法分开来写。
获得锁的线程会执行完毕后，才将锁交给下一个线程继续执行。
对于在静态方法上加锁：
package testThread;
public class Test2 {
public static void main(String[] args) {
Account account = new Account();
Account account1 = new Account();
//意思是这里虽然创建了两个不同的Account对象，但是获得的锁是同一个锁
User u_weChat = new User(account,);
User u_zhifubao = new User(account1,);
Thread wechat = new Thread(u_weChat,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
wechat.start();
zhifubao.start();
}
}
class Account{
public static int money = ;
//静态方法加同步锁之后，对于所有的对象都是同一个锁
public static synchronized void get(int m) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
}
class User implements Runnable{
Account account;
int money;
public User(Account account,int money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
// TODO Auto-generated method stub
account.get(money);
}
}
对于这种方式，即使传入的是该类的不同对象，仍然获得的是同一个锁。
正在运行：微信
微信操作-账户原有金额:3000
微信操作-取款金额:2000
微信操作-取款后的余额:1000
正在运行：支付宝
支付宝操作-账户金额不足:1000
还有一种方式是利用同步锁修饰代码块：
package testThread;
public class Test2 {
public static void main(String[] args) {
Account account = new Account();
Account account1 = new Account();
User u_weChat = new User(account,);
User u_zhifubao = new User(account1,);
Thread wechat = new Thread(u_weChat,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
wechat.start();
zhifubao.start();
}
}
class Account{
public static int money = ;
public void get2(int m) {
//用this锁代码块是代表当前的对象，如果在其它方法中也有synchronized(this)的代码块用的是同一个同步锁
synchronized (this) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
}
}
class User implements Runnable{
Account account;
int money;
public User(Account account,int money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
// TODO Auto-generated method stub
account.get2(money);
}
}
输出：
正在运行：支付宝
支付宝操作-账户原有金额:3000
支付宝操作-取款金额:2000
支付宝操作-取款后的余额:1000
正在运行：微信
微信操作-账户金额不足:1000
想要不同的对象有不同的锁：
package testThread;
public class Test2 {
public static void main(String[] args) {
Account account = new Account();
Account account1 = new Account();
User u_weChat = new User(account,);
User u_zhifubao = new User(account1,);
Thread wechat = new Thread(u_weChat,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
wechat.start();
zhifubao.start();
}
}
class Account{
public static int money = ;
public void get3(int m,Account a) {
//表示通过方法的参数传递进来的对象的代码块加了同步锁
//不同的对象有不同的同步锁
synchronized (a) {
String thread = Thread.currentThread().getName();
System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
}
}
}
class User implements Runnable{
Account account;
int money;
public User(Account account,int money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
// TODO Auto-generated method stub
account.get3(money,account);
}
}
输出：
正在运行：微信
正在运行：支付宝
微信操作-账户原有金额:3000
支付宝操作-账户原有金额:3000
微信操作-取款金额:2000
微信操作-取款后的余额:1000
支付宝操作-取款金额:2000
支付宝操作-取款后的余额:-1000
此时，这种加锁方式就没有效果了，与最开始的那种是一样的。
总而言之，要想使加锁有效果，必须获得的是同一个对象的锁。
五、线程之间的通信
wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问。
notify()：唤醒正在排队等待同步资源的线程中优先级较高者结束等待。
notifyAll()：唤醒正在排队等待资源的所有线程结束等待。
java.lang.Object提供的三个方法只有在sychronized方法或synchronized代码块中才能使用。
对于第四节提到到最后一种方式，只要将使用同一个Account对象，加锁机制就还是成功。但是我们会发现，之前的结果都是微信在支付宝之前进行操作，假设我们要让支付宝先操作，又应该怎么办呢？这时就需要利用线程之间的通信。
package testThread;
public class Test2 {
public static void main(String[] args) {
Account account = new Account();
User u_weChat = new User(account,);
User u_zhifubao = new User(account,);
Thread wechat = new Thread(u_weChat,"微信");
Thread zhifubao = new Thread(u_zhifubao,"支付宝");
wechat.start();
zhifubao.start();
}
}
class Account{
public static int money = ;
public void get4(int m,Account a) throws InterruptedException {
//表示通过方法的参数传递进来的对象的代码块加了同步锁
//不同的对象有不同的同步锁
synchronized (a) {
String thread = Thread.currentThread().getName();
//如果是微信操作，则暂时挂起，让支付宝先操作
if (thread.equals("微信")){
try {
a.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// System.out.println("正在运行："+thread);
if(money<m) {
System.out.println(thread+"操作-账户金额不足:" + money);
}else {
System.out.println(thread+"操作-账户原有金额:"+money);
System.out.println(thread+"操作-取款金额:"+m);
money = money - m;
System.out.println(thread+"操作-取款后的余额:"+money);
}
if (thread.equals("支付宝")){
a.notify();
}
}
}
}
class User implements Runnable{
Account account;
int money;
public User(Account account,int money) {
this.account = account;
this.money = money;
}
@Override
public void run() {
// TODO Auto-generated method stub
try {
account.get4(money,account);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
我们先让线程为“微信”的暂时挂起，先执行其它的，也就是支付宝，然后当支付宝执行完毕之后告知微信，这样就可以了。
输出：
支付宝操作-账户原有金额:3000
支付宝操作-取款金额:2000
支付宝操作-取款后的余额:1000
微信操作-账户金额不足:1000
这时，我们又想到，假设我们现在传入的是不同的Account对象呢？
我们先看下输出结果：
支付宝操作-账户原有金额:3000
支付宝操作-取款金额:2000
支付宝操作-取款后的余额:1000
程序一直在运行（这是我在notify if语句之前加的）
这说明了什么？支付宝运行结束后并没有成功告知微信，微信一直处于等待状态，其原因在于它们拥有的是不同对象的锁，因此之间不能通信。