假设我现在写一个类，里面有两个方法，我要调用几个线程来执行他，但是我需要一个同步锁，如果方法a是静态方法，b是普通方法，用synchronized锁住这两个线程，是不是锁住a的时候b依然会被调用？这样是不是还是不安全？

这样肯定是不行的。如下例：
public class Test {
        public static void main(String[] a) {
                new Thread(new Runnable() {

                        @Override
                        public void run() {
                                R.a();

                        }
                }).start();

                new Thread(new Runnable() {

                        @Override
                        public void run() {
                                new R().b();

                        }
                }).start();
        }
}

class R {
        static synchronized void a() {
                System.out.println("f1    1");
                try {
                        Thread.sleep(100);
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                System.out.println("f1    2");
        }

        synchronized void b() {
                System.out.println("f2    1");
                try {
                        Thread.sleep(100);
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                System.out.println("f2    2");
        }
}

输出结果是：

f1    1
f2    1
f1    2
f2    2

在非静态方法上加同步锁，锁定的是this，即创建的对象。
在静态方法上加同步锁，锁定的是类的字节码。

用synchronized锁住这两个方法是不安全的，因为他们不是同一个锁，普通方法用的是this，而静态方法用的是字节码文件对象，可以用同步代码块锁住方普通方法中的关键代码，如下：
synchronized(类名.class)
{
//关键代码
}
这样他们用的就是同一个锁了。

线程安不安全在于你的synchronized中的锁是否相同，锁（即synchronized中的对象）相同则安全