update is better if the same data is read over and over again. But if that is not the case, then the same value would be updated each time leading to bandwidth problems.
The reason why most modern solutions use invalidation-based protocols, rather than update-based protocols, is because update has the potential to unnecessarily incur much higher bandwidth.
Update is good for scenarios where two threads, for example, are writing to the same shared variable over and over again, but bad in scenarios when a value just sits in the cache of one processor, never to be used again, but another processor will continually update that value in the other cache.
The update-based protocols are good because you don't take cache misses, your cache lines don't get dropped, you don't have to flush to memory all the time, etc. However, this is at the expense of always writing to other processors' caches, which will lead to bandwidth problems.
The drawback of invalidation based is that it has to reload the data from memory as long as other processor modifies the line. But drawback can be mitigate by using complex implementation, such as loading the line from other cache.