1、线程模型
1）线程异步：多个线程之间独立执行，谁也不用等谁
线程同步：一个线程必需等另外一个线程执行完毕之后才能执行
备注：为了数据的安全，尽管应用程序的使用率低，但是为了保证数据是安全的，必须加入线程同步机制，线程同步机制使程序变成了（等同）单线程
2）什么条件下要使用线程同步？
第一: 必须是多线程环境
第二: 多线程环境共享同一个数据
第三: 共享的数据涉及到修改操作
3）同步方法和同步代码块的区别:
在 Java 语言中，每一个对象有一把锁。线程可以使用 synchronized 关键字来获取对象上的锁。synchronized 关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)
2、synchronized 锁的一些概念：
1）
java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法
java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去
java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的
2）synchronized的用法：synchronized 方法和synchronized 代码块
|示例：异步线程对同一账户进行取款操作|
存在t1已经取过款，但是t2取款后的余额显示的是t1未取款之前的金额
public class ThreadTest09 {
public static void main(String[] args) {
//创建一个公共账户：存款10000
Account publicAccount=new Account("acc-001",10000);
//异步线程同时对同一账户进行取款操作：
Processor09 pro=new Processor09(publicAccount);
Thread t1=new Thread(pro);
Thread t2=new Thread(pro);
t1.setName("t1");
t2.setName("t2");
//启动线程取款
t1.start();
t2.start();
}
}
//取款线程
class Processor09 implements Runnable{
Account acc;
public Processor09(Account account){
this.acc=account;
}
@Override
public void run() {
acc.withDraw(1000);
System.out.println(Thread.currentThread().getName()+"线程 "+
acc.getActno()+"账户"+"取款成功,余额："+acc.getBalance());
}
}
//账户信息：
class Account{
private String actno;
private double balance;
public Account(){
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String actno, double balance) {
super();
this.actno = actno;
this.balance = balance;
}
//对外提供一个取款的方法：
public void withDraw(double money){
double before=this.balance;
double after=before-money;
this.setBalance(after);
}
}
|对取款的方法加synchronized,以确保数据安全|
//使用同步线程机制以保障数据的安全
public class ThreadTest09 {
public static void main(String[] args) {
//创建一个公共账户：存款10000
Account publicAccount=new Account("acc-003",20000);
Processor09 pro=new Processor09(publicAccount);
Thread t1=new Thread(pro);
Thread t2=new Thread(pro);
t1.setName("t1");
t2.setName("t2");
//启动线程取款
t1.start();
t2.start();
}
}
//取款线程
class Processor09 implements Runnable{
Account acc;
public Processor09(Account account){
this.acc=account;
}
@Override
public void run() {
acc.withDraw(1000);
System.out.println(Thread.currentThread().getName()+"线程 "+
acc.getActno()+"账户"+"取款成功,余额："+acc.getBalance());
}
}
//账户信息：
class Account{
private String actno;
private double balance;
public Account(){
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String actno, double balance) {
super();
this.actno = actno;
this.balance = balance;
}
//对外提供一个取款的方法：
public synchronized void withDraw(double money){
double before=this.balance;
double after=before-money;
synchronized(this){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//更新账户余额
this.setBalance(after);
}
}
}
|示例：静态方法上添加synchronized锁设置|
synchronized添加到静态方法上，线程执行此方法的时候会找类锁
public class ThreadTest10 {
public static void main(String[] args) {
Thread thread1=new Thread(new Processor10());
Thread thread2=new Thread(new Processor10());
thread1.setName("t1");
thread2.setName("t2");
thread1.start();
try {
thread1.sleep(9000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
thread2.start();
}
}
class Processor10 implements Runnable{
@Override
public void run() {
if("t1".equals(Thread.currentThread().getName())){
MyClass.m1();
}
if("t2".equals(Thread.currentThread().getName())){
MyClass.m2();
}
}
}
class MyClass{
public synchronized static void m1(){
try {
Thread.sleep(1000);
System.out.println("m1-->"+"方法执行");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/* m2方法不会等m1结束，就会执行，因为该方法没有被synchronized修饰
public static void m2(){
System.out.println("m2-->"+"方法执行");
}
*/
//m2方法的执行需要等m1方法执行完，因为m2方法的执行需要类所，而类锁只有一个
public synchronized static void m2(){
System.out.println("m2-->"+"方法执行");
}
}
|示例：两个线程对一个共享的数据操作|
t1线程和t2线程对同一个num 操作
t1输出1个，t1唤醒其他的线程，t1等待
t2输出1个，t2唤醒其他的线程，t2等待
public class Num {
int count;
public Num(int count){
this.count=count;
}
//打印奇数的方法
public synchronized void printOdd(){
System.out.println(Thread.currentThread().getName()+"-->"+(count++));
this.notifyAll();
try {
Thread.sleep(1000);
this.wait();//t1线程无期限的等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//打印偶数的方法
public synchronized void printEven(){
System.out.println(Thread.currentThread().getName()+"-->"+(count++));
this.notifyAll();
try {
Thread.sleep(1000);
this.wait();//t2线程无期限的等待
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//线程1 负责打印奇数
public class PrintOdd implements Runnable {
Num num;
PrintOdd(Num num){
this.num=num;
}
@Override
public void run() {
//打印基数：
while(true){
num.printOdd();
}
}
}
//线程2 打印偶数
public class PrintEven implements Runnable {
Num num;
PrintEven(Num num){
this.num=num;
}
@Override
public void run() {
while(true){
num.printEven();
}
}
}
public class ThreadTest11 {
public static void main(String[] args) {
Num num=new Num(1);
Thread thread1=new Thread(new PrintOdd(num));
thread1.setName("t1");
Thread thread2=new Thread(new PrintEven(num));
thread2.setName("t2");
thread1.start();
thread2.start();
}
}
来源：https://www.cnblogs.com/jiarui-zjb/p/6228725.html